@storybloq/storybloq 1.4.2 → 1.4.3

package/dist/cli.js

@@ -1809,7 +1809,7 @@ var init_init = __esm({
     init_esm_shims();
     init_project_loader();
     init_errors();
-    STORY_GITIGNORE_ENTRIES = ["snapshots/", "status.json", "sessions/"];
+    STORY_GITIGNORE_ENTRIES = ["snapshots/", "status.json", "sessions/", "federation-cache.json"];
   }
 });
 
@@ -9424,7 +9424,7 @@ async function scanNodeSummary(storyDir, signal) {
   };
 }
 function withTimeout(promise, ms, controller) {
-  return new Promise((resolve15, reject) => {
+  return new Promise((resolve16, reject) => {
     const timer = setTimeout(() => {
       controller.abort();
       reject(new Error("timeout"));
@@ -9432,7 +9432,7 @@ function withTimeout(promise, ms, controller) {
     promise.then(
       (val) => {
         clearTimeout(timer);
-        resolve15(val);
+        resolve16(val);
       },
       (err) => {
         clearTimeout(timer);
@@ -11240,17 +11240,17 @@ __export(git_inspector_exports, {
 });
 import { execFile } from "child_process";
 async function git(cwd, args, parse) {
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     execFile("git", args, { cwd, timeout: GIT_TIMEOUT, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
       if (err) {
         const message = stderr?.trim() || err.message || "unknown git error";
-        resolve15({ ok: false, reason: "git_error", message });
+        resolve16({ ok: false, reason: "git_error", message });
         return;
       }
       try {
-        resolve15({ ok: true, data: parse(stdout) });
+        resolve16({ ok: true, data: parse(stdout) });
       } catch (parseErr) {
-        resolve15({ ok: false, reason: "parse_error", message: parseErr.message });
+        resolve16({ ok: false, reason: "parse_error", message: parseErr.message });
       }
     });
   });
@@ -11357,22 +11357,22 @@ async function gitIsAncestor(cwd, ancestor, descendant) {
   if (!SAFE_REF.test(ancestor) || !SAFE_REF.test(descendant)) {
     return { ok: false, reason: "git_error", message: "invalid ref format" };
   }
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     execFile(
       "git",
       ["merge-base", "--is-ancestor", ancestor, descendant],
       { cwd, timeout: GIT_TIMEOUT },
       (err) => {
         if (!err) {
-          resolve15({ ok: true, data: true });
+          resolve16({ ok: true, data: true });
           return;
         }
         const code = err.code;
         if (code === 1) {
-          resolve15({ ok: true, data: false });
+          resolve16({ ok: true, data: false });
           return;
         }
-        resolve15({ ok: false, reason: "git_error", message: err.message });
+        resolve16({ ok: false, reason: "git_error", message: err.message });
       }
     );
   });
@@ -11394,14 +11394,14 @@ async function gitLogRange(cwd, from, to, limit = 20) {
   );
 }
 async function gitHeadHash(cwd) {
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     execFile("git", ["rev-parse", "HEAD"], { cwd, timeout: 3e3 }, (err, stdout) => {
       if (err) {
         const message = err.stderr?.trim() || err.message || "unknown git error";
-        resolve15({ ok: false, reason: "git_error", message });
+        resolve16({ ok: false, reason: "git_error", message });
         return;
       }
-      resolve15({ ok: true, data: stdout.trim() });
+      resolve16({ ok: true, data: stdout.trim() });
     });
   });
 }
@@ -11419,7 +11419,7 @@ async function gitResolveCommit(cwd, hash) {
   if (!SAFE_REF.test(hash)) {
     return { ok: false, reason: "git_error", message: "invalid ref format" };
   }
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     execFile(
       "git",
       ["rev-parse", "--verify", `${hash}^{commit}`],
@@ -11427,10 +11427,10 @@ async function gitResolveCommit(cwd, hash) {
       (err, stdout, stderr) => {
         if (err) {
           const message = stderr?.trim() || err.message || "unknown git error";
-          resolve15({ ok: false, reason: "git_error", message });
+          resolve16({ ok: false, reason: "git_error", message });
           return;
         }
-        resolve15({ ok: true, data: stdout.trim() });
+        resolve16({ ok: true, data: stdout.trim() });
       }
     );
   });
@@ -11452,18 +11452,18 @@ async function gitCheckoutNewBranch(cwd, branchName, base) {
   return git(cwd, ["checkout", "-b", branchName, base], () => void 0);
 }
 async function gitBranchExists(cwd, branchName) {
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     execFile("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], { cwd, timeout: GIT_TIMEOUT }, (err) => {
       if (err) {
         const exitCode = err.code;
         if (exitCode === 1) {
-          resolve15({ ok: true, data: false });
+          resolve16({ ok: true, data: false });
         } else {
-          resolve15({ ok: false, reason: "git_error", message: err.message });
+          resolve16({ ok: false, reason: "git_error", message: err.message });
         }
         return;
       }
-      resolve15({ ok: true, data: true });
+      resolve16({ ok: true, data: true });
     });
   });
 }
@@ -11471,13 +11471,13 @@ async function gitCheckoutBranch(cwd, branchName) {
   return git(cwd, ["checkout", branchName], () => void 0);
 }
 async function gitCheckRefFormat(cwd, refName) {
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     execFile("git", ["check-ref-format", "--branch", refName], { cwd, timeout: GIT_TIMEOUT }, (err) => {
       if (err) {
-        resolve15({ ok: true, data: false });
+        resolve16({ ok: true, data: false });
         return;
       }
-      resolve15({ ok: true, data: true });
+      resolve16({ ok: true, data: true });
     });
   });
 }
@@ -17571,7 +17571,7 @@ function getInstalledVersion() {
   }
 }
 function getRunningVersion() {
-  return "1.4.2";
+  return "1.4.3";
 }
 var init_version_check = __esm({
   "src/autonomous/version-check.ts"() {
@@ -19863,7 +19863,7 @@ function registerAllTools(server, pinnedRoot) {
     const result = await runMcpReadTool(pinnedRoot, handleStatus);
     try {
       const { readUpdateCacheSync: readUpdateCacheSync2, refreshUpdateCacheInBackground: refreshUpdateCacheInBackground2 } = await Promise.resolve().then(() => (init_update_check(), update_check_exports));
-      const running = "1.4.2";
+      const running = "1.4.3";
       const info = readUpdateCacheSync2(running);
       refreshUpdateCacheInBackground2();
       if (info?.updateAvailable && result.content[0]?.type === "text") {
@@ -21506,7 +21506,7 @@ var init_mcp = __esm({
     ENV_VAR2 = "STORYBLOQ_PROJECT_ROOT";
     LEGACY_ENV_VAR2 = "CLAUDESTORY_PROJECT_ROOT";
     CONFIG_PATH2 = ".story/config.json";
-    version = "1.4.2";
+    version = "1.4.3";
     main().catch((err) => {
       process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}
 `);
@@ -22973,7 +22973,7 @@ function codePrompt(sessionId) {
   ].join(" ");
 }
 async function runCodexExec(root, prompt, schemaPath, outputPath, timeoutMs) {
-  await new Promise((resolve15, reject) => {
+  await new Promise((resolve16, reject) => {
     const child = spawn3("codex", [
       "exec",
       "--ephemeral",
@@ -23016,7 +23016,7 @@ async function runCodexExec(root, prompt, schemaPath, outputPath, timeoutMs) {
       if (timedOut) {
         finish(() => reject(new Error(`codex exec timed out after ${Math.round(timeoutMs / 1e3)} seconds`)));
       } else if (code === 0) {
-        finish(() => resolve15());
+        finish(() => resolve16());
       } else {
         finish(() => reject(new Error(`codex exec exited with status ${code}: ${stderr.trim()}`)));
       }
@@ -23110,6 +23110,64 @@ var init_codex_review = __esm({
   }
 });
 
+// src/core/symlink-write.ts
+import { lstat as lstat3, mkdir as mkdir7, readlink, realpath as realpath2, rename as rename3, unlink as unlink4, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname8, isAbsolute as isAbsolute3, resolve as resolve15 } from "path";
+async function resolveSymlinkTarget(path2) {
+  try {
+    return await realpath2(path2);
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+    let cur = path2;
+    for (let depth = 0; depth < MAX_SYMLINK_DEPTH; depth++) {
+      const link = await readlink(cur);
+      const next = isAbsolute3(link) ? link : resolve15(dirname8(cur), link);
+      let st;
+      try {
+        st = await lstat3(next);
+      } catch (le) {
+        if (le.code === "ENOENT") return next;
+        throw le;
+      }
+      if (st.isSymbolicLink()) {
+        cur = next;
+        continue;
+      }
+      return next;
+    }
+    throw new Error(`symlink chain too deep at ${path2}`);
+  }
+}
+async function atomicWriteFollowingSymlink(targetPath, contents) {
+  let st = null;
+  try {
+    st = await lstat3(targetPath);
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  }
+  const realTarget = st?.isSymbolicLink() ? await resolveSymlinkTarget(targetPath) : targetPath;
+  const tmpPath = `${realTarget}.${process.pid}.tmp`;
+  try {
+    await mkdir7(dirname8(realTarget), { recursive: true });
+    await writeFile4(tmpPath, contents, "utf-8");
+    await rename3(tmpPath, realTarget);
+  } catch (err) {
+    try {
+      await unlink4(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+}
+var MAX_SYMLINK_DEPTH;
+var init_symlink_write = __esm({
+  "src/core/symlink-write.ts"() {
+    "use strict";
+    init_esm_shims();
+    MAX_SYMLINK_DEPTH = 40;
+  }
+});
+
 // src/core/hook-migration.ts
 var hook_migration_exports = {};
 __export(hook_migration_exports, {
@@ -23123,10 +23181,10 @@ __export(hook_migration_exports, {
   parseHookCommand: () => parseHookCommand,
   sweepLegacyHooks: () => sweepLegacyHooks
 });
-import { mkdir as mkdir7, readFile as readFile10, rename as rename3, unlink as unlink4, writeFile as writeFile4 } from "fs/promises";
+import { readFile as readFile10 } from "fs/promises";
 import { existsSync as existsSync22 } from "fs";
 import { homedir as homedir4 } from "os";
-import { basename as basename5, dirname as dirname8, join as join51 } from "path";
+import { basename as basename5, join as join51 } from "path";
 function defaultSettingsPath() {
   return join51(homedir4(), ".claude", "settings.json");
 }
@@ -23253,17 +23311,9 @@ async function migrateLegacyHookVariants(hookType, subcommand, newCommand, setti
     removedCount += before - g.hooks.length;
   }
   if (removedCount === 0) return 0;
-  const tmpPath = `${path2}.${process.pid}.tmp`;
   try {
-    const dir = dirname8(path2);
-    await mkdir7(dir, { recursive: true });
-    await writeFile4(tmpPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
-    await rename3(tmpPath, path2);
+    await atomicWriteFollowingSymlink(path2, JSON.stringify(settings, null, 2) + "\n");
   } catch {
-    try {
-      await unlink4(tmpPath);
-    } catch {
-    }
     return 0;
   }
   return removedCount;
@@ -23341,6 +23391,7 @@ var init_hook_migration = __esm({
   "src/core/hook-migration.ts"() {
     "use strict";
     init_esm_shims();
+    init_symlink_write();
     PRECOMPACT_SUBCOMMAND = "session compact-prepare";
     SESSIONSTART_SUBCOMMAND = "session resume-prompt";
     STOP_SUBCOMMAND = "hook-status";
@@ -23458,6 +23509,7 @@ __export(setup_skill_exports, {
   SESSIONSTART_SUBCOMMAND: () => SESSIONSTART_SUBCOMMAND,
   STOP_SUBCOMMAND: () => STOP_SUBCOMMAND,
   STORYBLOQ_LEGACY_BASENAMES: () => STORYBLOQ_LEGACY_BASENAMES,
+  __copyDirRecursiveForTest: () => __copyDirRecursiveForTest,
   copyDirRecursive: () => copyDirRecursive,
   ensureCodexClientEnv: () => ensureCodexClientEnv,
   ensureCodexToolApprovals: () => ensureCodexToolApprovals,
@@ -23478,7 +23530,7 @@ __export(setup_skill_exports, {
   resolveStorybloqBin: () => resolveStorybloqBin,
   sweepLegacyHooks: () => sweepLegacyHooks
 });
-import { mkdir as mkdir8, writeFile as writeFile5, readFile as readFile11, readdir as readdir7, copyFile, rm, rename as rename4, unlink as unlink5 } from "fs/promises";
+import { mkdir as mkdir8, writeFile as writeFile5, readFile as readFile11, readdir as readdir7, copyFile, rm, rename as rename4, lstat as lstat4 } from "fs/promises";
 import { existsSync as existsSync24, accessSync as accessSync4, readdirSync as readdirSync9, constants as fsConstants } from "fs";
 import { join as join53, dirname as dirname9, delimiter as pathDelimiter } from "path";
 import { homedir as homedir6 } from "os";
@@ -23500,10 +23552,38 @@ function resolveSkillSourceDir() {
   );
 }
 async function copyDirRecursive(srcDir, destDir) {
-  const tmpDir = destDir + ".tmp";
-  const bakDir = destDir + ".bak";
-  if (!existsSync24(destDir) && existsSync24(bakDir)) {
-    await rename4(bakDir, destDir);
+  return runCopyDir(srcDir, destDir);
+}
+async function __copyDirRecursiveForTest(srcDir, destDir, testHooks) {
+  return runCopyDir(srcDir, destDir, testHooks);
+}
+async function runCopyDir(srcDir, destDir, testHooks) {
+  let st = null;
+  try {
+    st = await lstat4(destDir);
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  }
+  let targetDir = destDir;
+  if (st?.isSymbolicLink()) {
+    targetDir = await resolveSymlinkTarget(destDir);
+    let resolvedStat = null;
+    try {
+      resolvedStat = await lstat4(targetDir);
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+    }
+    if (resolvedStat && !resolvedStat.isDirectory()) {
+      throw new Error(`refusing to replace non-directory symlink target: ${targetDir}`);
+    }
+  }
+  return copyDirSwap(srcDir, targetDir, testHooks);
+}
+async function copyDirSwap(srcDir, targetDir, testHooks) {
+  const tmpDir = targetDir + ".tmp";
+  const bakDir = targetDir + ".bak";
+  if (!existsSync24(targetDir) && existsSync24(bakDir)) {
+    await rename4(bakDir, targetDir);
   }
   if (existsSync24(tmpDir)) await rm(tmpDir, { recursive: true, force: true });
   if (existsSync24(bakDir)) await rm(bakDir, { recursive: true, force: true });
@@ -23520,13 +23600,14 @@ async function copyDirRecursive(srcDir, destDir) {
     await copyFile(srcPath, destPath);
     written.push(relativePath);
   }
-  if (existsSync24(destDir)) {
-    await rename4(destDir, bakDir);
+  if (existsSync24(targetDir)) {
+    await rename4(targetDir, bakDir);
   }
   try {
-    await rename4(tmpDir, destDir);
+    if (testHooks?.beforeSwapRename) await testHooks.beforeSwapRename();
+    await rename4(tmpDir, targetDir);
   } catch (err) {
-    if (existsSync24(bakDir)) await rename4(bakDir, destDir).catch(() => {
+    if (existsSync24(bakDir)) await rename4(bakDir, targetDir).catch(() => {
     });
     await rm(tmpDir, { recursive: true, force: true }).catch(() => {
     });
@@ -23687,17 +23768,9 @@ async function registerHook(hookType, hookEntry, settingsPath, matcher) {
   if (!appended) {
     hookArray.push({ matcher: targetMatcher, hooks: [hookEntry] });
   }
-  const tmpPath = `${path2}.${process.pid}.tmp`;
   try {
-    const dir = dirname9(path2);
-    await mkdir8(dir, { recursive: true });
-    await writeFile5(tmpPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
-    await rename4(tmpPath, path2);
+    await atomicWriteFollowingSymlink(path2, JSON.stringify(settings, null, 2) + "\n");
   } catch (err) {
-    try {
-      await unlink5(tmpPath);
-    } catch {
-    }
     const message = err instanceof Error ? err.message : String(err);
     process.stderr.write(`Failed to write settings.json: ${message}
 `);
@@ -23751,17 +23824,9 @@ async function removeHook(hookType, command, settingsPath) {
     if (g.hooks.length < before) removed = true;
   }
   if (!removed) return "not_found";
-  const tmpPath = `${path2}.${process.pid}.tmp`;
   try {
-    const dir = dirname9(path2);
-    await mkdir8(dir, { recursive: true });
-    await writeFile5(tmpPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
-    await rename4(tmpPath, path2);
+    await atomicWriteFollowingSymlink(path2, JSON.stringify(settings, null, 2) + "\n");
   } catch {
-    try {
-      await unlink5(tmpPath);
-    } catch {
-    }
     return "skipped";
   }
   return "removed";
@@ -24009,16 +24074,9 @@ approval_mode = "approve"
     if (next.length > 0 && !next.endsWith("\n\n")) next += "\n";
     next += additions.join("\n");
   }
-  const tmpPath = `${configPath}.${process.pid}.tmp`;
   try {
-    await mkdir8(dirname9(configPath), { recursive: true });
-    await writeFile5(tmpPath, next, "utf-8");
-    await rename4(tmpPath, configPath);
+    await atomicWriteFollowingSymlink(configPath, next);
   } catch (err) {
-    try {
-      await unlink5(tmpPath);
-    } catch {
-    }
     const message = err instanceof Error ? err.message : String(err);
     process.stderr.write(`Failed to write Codex config.toml: ${message}
 `);
@@ -24098,16 +24156,9 @@ async function ensureCodexClientEnv(configPath = codexConfigPath()) {
 STORYBLOQ_CLIENT = "codex"
 `;
   }
-  const tmpPath = `${configPath}.${process.pid}.tmp`;
   try {
-    await mkdir8(dirname9(configPath), { recursive: true });
-    await writeFile5(tmpPath, next, "utf-8");
-    await rename4(tmpPath, configPath);
+    await atomicWriteFollowingSymlink(configPath, next);
   } catch (err) {
-    try {
-      await unlink5(tmpPath);
-    } catch {
-    }
     const message = err instanceof Error ? err.message : String(err);
     process.stderr.write(`Failed to write Codex config.toml: ${message}
 `);
@@ -24154,16 +24205,9 @@ async function migrateCodexHookVariants(hookType, acceptedRests, newCommand, hoo
     removedCount += before - g.hooks.length;
   }
   if (removedCount === 0) return 0;
-  const tmpPath = `${hooksPath}.${process.pid}.tmp`;
   try {
-    await mkdir8(dirname9(hooksPath), { recursive: true });
-    await writeFile5(tmpPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
-    await rename4(tmpPath, hooksPath);
+    await atomicWriteFollowingSymlink(hooksPath, JSON.stringify(settings, null, 2) + "\n");
   } catch {
-    try {
-      await unlink5(tmpPath);
-    } catch {
-    }
     return 0;
   }
   return removedCount;
@@ -24239,16 +24283,9 @@ async function registerCodexHook(hookType, hookEntry, hooksPath = codexHooksPath
     if (targetMatcher) group.matcher = targetMatcher;
     hookArray.push(group);
   }
-  const tmpPath = `${hooksPath}.${process.pid}.tmp`;
   try {
-    await mkdir8(dirname9(hooksPath), { recursive: true });
-    await writeFile5(tmpPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
-    await rename4(tmpPath, hooksPath);
+    await atomicWriteFollowingSymlink(hooksPath, JSON.stringify(settings, null, 2) + "\n");
   } catch (err) {
-    try {
-      await unlink5(tmpPath);
-    } catch {
-    }
     const message = err instanceof Error ? err.message : String(err);
     process.stderr.write(`Failed to write Codex hooks.json: ${message}
 `);
@@ -24276,8 +24313,14 @@ async function handleSetupCodex(options = {}) {
   log(`  ${writtenFiles.join(" + ")} written`);
   const compatSkillDir = join53(codexHome(), "skills", "story");
   if (existsSync24(join53(compatSkillDir, "SKILL.md"))) {
-    const compatFiles = await copyDirRecursive(srcSkillDir, compatSkillDir);
-    log(`  Refreshed existing Codex skill copy at ${compatSkillDir}/ (${compatFiles.length} files)`);
+    try {
+      const compatFiles = await copyDirRecursive(srcSkillDir, compatSkillDir);
+      log(`  Refreshed existing Codex skill copy at ${compatSkillDir}/ (${compatFiles.length} files)`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Warning: Codex skill copy refresh failed: ${msg}
+`);
+    }
   }
   let cliInPath = false;
   try {
@@ -24400,6 +24443,7 @@ var init_setup_skill = __esm({
   "src/cli/commands/setup-skill.ts"() {
     "use strict";
     init_esm_shims();
+    init_symlink_write();
     init_hook_migration();
     LEGACY_PRECOMPACT_HOOK_COMMAND = "storybloq snapshot --quiet";
     CODEX_READ_ONLY_APPROVAL_TOOLS = [
@@ -25347,7 +25391,7 @@ function renderRepairSummary(toSupersede, skippedPreLock, mutationSkipped, resul
   return lines.join("\n");
 }
 async function readOneLine(stream) {
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     let buf = "";
     let done = false;
     const onData = (chunk) => {
@@ -25358,7 +25402,7 @@ async function readOneLine(stream) {
         done = true;
         stream.removeListener("data", onData);
         stream.removeListener("end", onEnd);
-        resolve15(buf.slice(0, nl));
+        resolve16(buf.slice(0, nl));
       }
     };
     const onEnd = () => {
@@ -25366,7 +25410,7 @@ async function readOneLine(stream) {
       done = true;
       stream.removeListener("data", onData);
       stream.removeListener("end", onEnd);
-      resolve15(buf);
+      resolve16(buf);
     };
     stream.on("data", onData);
     stream.on("end", onEnd);
@@ -25572,6 +25616,220 @@ var init_session_watch = __esm({
   }
 });
 
+// src/feedback/github-client.ts
+async function fetchIssues(options) {
+  const params = new URLSearchParams({
+    state: "open",
+    per_page: String(options.limit ?? 100)
+  });
+  if (options.category) {
+    const label = CATEGORY_TO_LABEL[options.category] ?? options.category;
+    params.set("labels", label);
+  }
+  const url = `${API_BASE}/issues?${params.toString()}`;
+  let response;
+  try {
+    response = await fetch(url, {
+      headers: {
+        Accept: "application/vnd.github+json",
+        "User-Agent": "storybloq-cli"
+      }
+    });
+  } catch (err) {
+    throw new FeedbackClientError(
+      "network_error",
+      `Failed to reach GitHub API: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (!response.ok) {
+    throw new FeedbackClientError(
+      "api_error",
+      `GitHub API returned ${response.status}`
+    );
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch {
+    throw new FeedbackClientError("parse_error", "Failed to parse GitHub API response");
+  }
+  data = data.filter((issue) => !issue.pull_request);
+  let rateLimitWarning = null;
+  const remaining = response.headers.get("X-RateLimit-Remaining");
+  if (remaining !== null) {
+    const n = parseInt(remaining, 10);
+    if (!isNaN(n) && n < 10) {
+      rateLimitWarning = `GitHub API rate limit low: ${n} requests remaining`;
+    }
+  }
+  return { issues: data, rateLimitWarning };
+}
+var REPO, API_BASE, CATEGORY_TO_LABEL, FeedbackClientError;
+var init_github_client = __esm({
+  "src/feedback/github-client.ts"() {
+    "use strict";
+    init_esm_shims();
+    REPO = "Storybloq/storybloq";
+    API_BASE = `https://api.github.com/repos/${REPO}`;
+    CATEGORY_TO_LABEL = {
+      bug: "bug",
+      feature: "enhancement",
+      idea: "idea"
+    };
+    FeedbackClientError = class extends Error {
+      code;
+      constructor(code, message) {
+        super(message);
+        this.name = "FeedbackClientError";
+        this.code = code;
+      }
+    };
+  }
+});
+
+// src/cli/commands/feedback.ts
+var feedback_exports = {};
+__export(feedback_exports, {
+  buildCreateURL: () => buildCreateURL,
+  handleFeedbackCreate: () => handleFeedbackCreate,
+  handleFeedbackList: () => handleFeedbackList,
+  handleFeedbackOpen: () => handleFeedbackOpen,
+  handleFeedbackVote: () => handleFeedbackVote,
+  openBrowser: () => openBrowser
+});
+import { spawn as spawn4 } from "child_process";
+function labelToCategory(labels) {
+  for (const l of labels) {
+    if (l.name === "bug") return "bug";
+    if (l.name === "enhancement") return "feature";
+    if (l.name === "idea") return "idea";
+  }
+  return "-";
+}
+function relativeDate(iso) {
+  const ms = Date.now() - new Date(iso).getTime();
+  const mins = Math.floor(ms / 6e4);
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+function openBrowser(url) {
+  const platform = process.platform;
+  let cmd;
+  let args;
+  if (platform === "darwin") {
+    cmd = "open";
+    args = [url];
+  } else if (platform === "win32") {
+    cmd = "powershell.exe";
+    args = ["-NoProfile", "-Command", "Start-Process $args[0]", "-args", url];
+  } else {
+    cmd = "xdg-open";
+    args = [url];
+  }
+  const child = spawn4(cmd, args, { detached: true, stdio: "ignore" });
+  child.unref();
+}
+async function handleFeedbackOpen() {
+  openBrowser(`${REPO_URL}/issues`);
+  return { output: `Opened ${REPO_URL}/issues`, exitCode: ExitCode.OK };
+}
+async function handleFeedbackList(options, format) {
+  try {
+    const result = await fetchIssues(options);
+    if (format === "json") {
+      return {
+        output: JSON.stringify(successEnvelope({
+          issues: result.issues.map((i) => ({
+            number: i.number,
+            title: i.title,
+            category: labelToCategory(i.labels),
+            votes: i.reactions["+1"],
+            date: i.created_at,
+            url: i.html_url
+          })),
+          rateLimitWarning: result.rateLimitWarning
+        }), null, 2),
+        exitCode: ExitCode.OK
+      };
+    }
+    if (result.issues.length === 0) {
+      let msg = "No feedback found.";
+      if (result.rateLimitWarning) msg += `
+
+${result.rateLimitWarning}`;
+      return { output: msg, exitCode: ExitCode.OK };
+    }
+    const rows = result.issues.map(
+      (i) => `| ${i.number} | ${i.title} | ${labelToCategory(i.labels)} | ${i.reactions["+1"]} | ${relativeDate(i.created_at)} |`
+    );
+    let output = "# Community Feedback\n\n";
+    output += "| # | Title | Category | Votes | Date |\n";
+    output += "|---|-------|----------|-------|------|\n";
+    output += rows.join("\n");
+    if (result.rateLimitWarning) {
+      output += `
+
+> ${result.rateLimitWarning}`;
+    }
+    return { output, exitCode: ExitCode.OK };
+  } catch (err) {
+    if (err instanceof FeedbackClientError) {
+      return { output: `Error: ${err.message}`, exitCode: ExitCode.USER_ERROR };
+    }
+    throw err;
+  }
+}
+function buildCreateURL(title, category, body) {
+  const params = new URLSearchParams();
+  params.set("title", title);
+  const version2 = process.env.npm_package_version ?? "unknown";
+  const footer = `
+
+---
+*Submitted via \`storybloq feedback create\`*
+CLI version: ${version2}
+Platform: ${process.platform}
+Node: ${process.version}`;
+  params.set("body", (body ?? "") + footer);
+  if (category) {
+    const label = CATEGORY_TO_LABEL[category] ?? category;
+    params.set("labels", label);
+  }
+  return `${REPO_URL}/issues/new?${params.toString()}`;
+}
+async function handleFeedbackCreate(title, category, body) {
+  const trimmed = title.trim();
+  if (!trimmed) {
+    return { output: "Error: Title is required", exitCode: ExitCode.USER_ERROR };
+  }
+  const url = buildCreateURL(trimmed, category, body);
+  openBrowser(url);
+  return { output: `Opening browser to create feedback...
+${url}`, exitCode: ExitCode.OK };
+}
+async function handleFeedbackVote(issueNumber) {
+  if (!issueNumber || issueNumber <= 0) {
+    return { output: "Error: Issue number must be a positive integer", exitCode: ExitCode.USER_ERROR };
+  }
+  const url = `${REPO_URL}/issues/${issueNumber}`;
+  openBrowser(url);
+  return { output: `Opening issue #${issueNumber} to vote...
+${url}`, exitCode: ExitCode.OK };
+}
+var REPO_URL;
+var init_feedback = __esm({
+  "src/cli/commands/feedback.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_github_client();
+    init_output_formatter();
+    REPO_URL = "https://github.com/Storybloq/storybloq";
+  }
+});
+
 // src/cli/register.ts
 var register_exports = {};
 __export(register_exports, {
@@ -25580,6 +25838,7 @@ __export(register_exports, {
   registerConfigCommand: () => registerConfigCommand,
   registerDispatchCommand: () => registerDispatchCommand,
   registerExportCommand: () => registerExportCommand,
+  registerFeedbackCommand: () => registerFeedbackCommand,
   registerHandoverCommand: () => registerHandoverCommand,
   registerHookStatusCommand: () => registerHookStatusCommand,
   registerInitCommand: () => registerInitCommand,
@@ -28503,6 +28762,82 @@ function registerSessionCommand(yargs) {
     }
   );
 }
+function registerFeedbackCommand(yargs) {
+  return yargs.command(
+    "feedback [subcommand]",
+    "Community feedback via GitHub Issues",
+    (y) => y.command(
+      "list",
+      "List community feedback",
+      (sub) => sub.option("category", {
+        type: "string",
+        choices: ["bug", "feature", "idea"],
+        describe: "Filter by category"
+      }).option("format", {
+        type: "string",
+        default: "md",
+        choices: ["md", "json"],
+        describe: "Output format"
+      }),
+      async (argv) => {
+        const { handleFeedbackList: handleFeedbackList2 } = await Promise.resolve().then(() => (init_feedback(), feedback_exports));
+        const result = await handleFeedbackList2(
+          { category: argv.category },
+          argv.format
+        );
+        process.stdout.write(result.output + "\n");
+        if (result.exitCode) process.exitCode = result.exitCode;
+      }
+    ).command(
+      "create",
+      "Create new feedback (opens browser)",
+      (sub) => sub.option("title", {
+        type: "string",
+        demandOption: true,
+        describe: "Feedback title"
+      }).option("category", {
+        type: "string",
+        choices: ["bug", "feature", "idea"],
+        describe: "Feedback category"
+      }).option("body", {
+        type: "string",
+        describe: "Feedback body"
+      }),
+      async (argv) => {
+        const { handleFeedbackCreate: handleFeedbackCreate2 } = await Promise.resolve().then(() => (init_feedback(), feedback_exports));
+        const result = await handleFeedbackCreate2(
+          argv.title,
+          argv.category,
+          argv.body
+        );
+        process.stdout.write(result.output + "\n");
+        if (result.exitCode) process.exitCode = result.exitCode;
+      }
+    ).command(
+      "vote <number>",
+      "Vote on feedback (opens browser)",
+      (sub) => sub.positional("number", {
+        type: "number",
+        demandOption: true,
+        describe: "Issue number"
+      }),
+      async (argv) => {
+        const { handleFeedbackVote: handleFeedbackVote2 } = await Promise.resolve().then(() => (init_feedback(), feedback_exports));
+        const result = await handleFeedbackVote2(argv.number);
+        process.stdout.write(result.output + "\n");
+        if (result.exitCode) process.exitCode = result.exitCode;
+      }
+    ),
+    async (argv) => {
+      if (!argv.subcommand || argv.subcommand === "feedback") {
+        const { handleFeedbackOpen: handleFeedbackOpen2 } = await Promise.resolve().then(() => (init_feedback(), feedback_exports));
+        const result = await handleFeedbackOpen2();
+        process.stdout.write(result.output + "\n");
+        if (result.exitCode) process.exitCode = result.exitCode;
+      }
+    }
+  );
+}
 var init_register = __esm({
   "src/cli/register.ts"() {
     "use strict";
@@ -28605,9 +28940,10 @@ async function runCli() {
     registerSessionCommand: registerSessionCommand2,
     registerRepairCommand: registerRepairCommand2,
     registerMigrateCommand: registerMigrateCommand2,
-    registerNodeCommand: registerNodeCommand2
+    registerNodeCommand: registerNodeCommand2,
+    registerFeedbackCommand: registerFeedbackCommand2
   } = await Promise.resolve().then(() => (init_register(), register_exports));
-  const version2 = "1.4.2";
+  const version2 = "1.4.3";
   const { preCommandHousekeeping: preCommandHousekeeping2 } = await Promise.resolve().then(() => (init_housekeeping(), housekeeping_exports));
   await preCommandHousekeeping2(version2);
   class HandledError extends Error {
@@ -28657,6 +28993,7 @@ async function runCli() {
   cli = registerConfigCommand2(cli);
   cli = registerNodeCommand2(cli);
   cli = registerSessionCommand2(cli);
+  cli = registerFeedbackCommand2(cli);
   function handleUnexpectedError(err) {
     if (err instanceof HandledError) return;
     const message = err instanceof Error ? err.message : String(err);

package/dist/index.d.ts

@@ -1503,16 +1503,49 @@ declare const SnapshotV1Schema: z.ZodObject<{
         file: z.ZodString;
         message: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        message: string;
         type: string;
+        message: string;
         file: string;
     }, {
-        message: string;
         type: string;
+        message: string;
         file: string;
     }>, "many">>;
     gitHead: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
+    version: 1;
+    config: {
+        version: number;
+        type: string;
+        language: string;
+        project: string;
+        features: {
+            issues: boolean;
+            tickets: boolean;
+            handovers: boolean;
+            roadmap: boolean;
+            reviews: boolean;
+        } & {
+            [k: string]: unknown;
+        };
+        orchestrator?: string | undefined;
+        nodes?: Record<string, unknown> | undefined;
+        federation?: Record<string, unknown> | undefined;
+        schemaVersion?: number | undefined;
+        recipe?: string | undefined;
+        recipeOverrides?: {
+            maxTicketsPerSession?: number | undefined;
+            compactThreshold?: string | undefined;
+            reviewBackends?: string[] | undefined;
+            codexReviewBackends?: string[] | undefined;
+            handoverInterval?: number | undefined;
+            stages?: Record<string, Record<string, unknown>> | undefined;
+            branchStrategy?: "none" | "per-ticket" | undefined;
+            maxParallelAgents?: number | undefined;
+        } | undefined;
+    } & {
+        [k: string]: unknown;
+    };
     issues: z.objectOutputType<{
         id: z.ZodString;
         title: z.ZodString;
@@ -1550,8 +1583,8 @@ declare const SnapshotV1Schema: z.ZodObject<{
         crossNodeBlockedBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, z.ZodTypeAny, "passthrough">[];
     roadmap: {
-        title: string;
         date: string;
+        title: string;
         phases: z.objectOutputType<{
             id: z.ZodString;
             label: z.ZodString;
@@ -1569,7 +1602,6 @@ declare const SnapshotV1Schema: z.ZodObject<{
     } & {
         [k: string]: unknown;
     };
-    version: 1;
     project: string;
     notes: z.objectOutputType<{
         id: z.ZodString;
@@ -1594,11 +1626,21 @@ declare const SnapshotV1Schema: z.ZodObject<{
         supersedes: z.ZodNullable<z.ZodString>;
         status: z.ZodEnum<["active", "deprecated", "superseded"]>;
     }, z.ZodTypeAny, "passthrough">[];
-    config: {
+    createdAt: string;
+    handoverFilenames: string[];
+    warnings?: {
         type: string;
+        message: string;
+        file: string;
+    }[] | undefined;
+    gitHead?: string | undefined;
+}, {
+    version: 1;
+    config: {
         version: number;
-        project: string;
+        type: string;
         language: string;
+        project: string;
         features: {
             issues: boolean;
             tickets: boolean;
@@ -1626,15 +1668,6 @@ declare const SnapshotV1Schema: z.ZodObject<{
     } & {
         [k: string]: unknown;
     };
-    createdAt: string;
-    handoverFilenames: string[];
-    warnings?: {
-        message: string;
-        type: string;
-        file: string;
-    }[] | undefined;
-    gitHead?: string | undefined;
-}, {
     issues: z.objectInputType<{
         id: z.ZodString;
         title: z.ZodString;
@@ -1672,8 +1705,8 @@ declare const SnapshotV1Schema: z.ZodObject<{
         crossNodeBlockedBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, z.ZodTypeAny, "passthrough">[];
     roadmap: {
-        title: string;
         date: string;
+        title: string;
         phases: z.objectInputType<{
             id: z.ZodString;
             label: z.ZodString;
@@ -1691,40 +1724,7 @@ declare const SnapshotV1Schema: z.ZodObject<{
     } & {
         [k: string]: unknown;
     };
-    version: 1;
     project: string;
-    config: {
-        type: string;
-        version: number;
-        project: string;
-        language: string;
-        features: {
-            issues: boolean;
-            tickets: boolean;
-            handovers: boolean;
-            roadmap: boolean;
-            reviews: boolean;
-        } & {
-            [k: string]: unknown;
-        };
-        orchestrator?: string | undefined;
-        nodes?: Record<string, unknown> | undefined;
-        federation?: Record<string, unknown> | undefined;
-        schemaVersion?: number | undefined;
-        recipe?: string | undefined;
-        recipeOverrides?: {
-            maxTicketsPerSession?: number | undefined;
-            compactThreshold?: string | undefined;
-            reviewBackends?: string[] | undefined;
-            codexReviewBackends?: string[] | undefined;
-            handoverInterval?: number | undefined;
-            stages?: Record<string, Record<string, unknown>> | undefined;
-            branchStrategy?: "none" | "per-ticket" | undefined;
-            maxParallelAgents?: number | undefined;
-        } | undefined;
-    } & {
-        [k: string]: unknown;
-    };
     createdAt: string;
     notes?: z.objectInputType<{
         id: z.ZodString;
@@ -1750,8 +1750,8 @@ declare const SnapshotV1Schema: z.ZodObject<{
         status: z.ZodEnum<["active", "deprecated", "superseded"]>;
     }, z.ZodTypeAny, "passthrough">[] | undefined;
     warnings?: {
-        message: string;
         type: string;
+        message: string;
         file: string;
     }[] | undefined;
     handoverFilenames?: string[] | undefined;

package/dist/index.js

@@ -2453,7 +2453,7 @@ async function initProject(root, options) {
     warnings
   };
 }
-var STORY_GITIGNORE_ENTRIES = ["snapshots/", "status.json", "sessions/"];
+var STORY_GITIGNORE_ENTRIES = ["snapshots/", "status.json", "sessions/", "federation-cache.json"];
 async function ensureGitignoreEntries(gitignorePath, entries) {
   let existing = "";
   try {

package/dist/mcp.js

@@ -6064,7 +6064,7 @@ async function initProject(root, options) {
     warnings
   };
 }
-var STORY_GITIGNORE_ENTRIES = ["snapshots/", "status.json", "sessions/"];
+var STORY_GITIGNORE_ENTRIES = ["snapshots/", "status.json", "sessions/", "federation-cache.json"];
 async function ensureGitignoreEntries(gitignorePath, entries) {
   let existing = "";
   try {
@@ -16743,7 +16743,7 @@ function getInstalledVersion() {
   }
 }
 function getRunningVersion() {
-  return "1.4.2";
+  return "1.4.3";
 }
 
 // src/autonomous/guide.ts
@@ -18753,7 +18753,7 @@ function registerAllTools(server, pinnedRoot) {
     const result = await runMcpReadTool(pinnedRoot, handleStatus);
     try {
       const { readUpdateCacheSync: readUpdateCacheSync2, refreshUpdateCacheInBackground: refreshUpdateCacheInBackground2 } = await Promise.resolve().then(() => (init_update_check(), update_check_exports));
-      const running = "1.4.2";
+      const running = "1.4.3";
       const info = readUpdateCacheSync2(running);
       refreshUpdateCacheInBackground2();
       if (info?.updateAvailable && result.content[0]?.type === "text") {
@@ -20112,7 +20112,7 @@ async function trimFailedDirectory(inboxPath) {
 var ENV_VAR2 = "STORYBLOQ_PROJECT_ROOT";
 var LEGACY_ENV_VAR2 = "CLAUDESTORY_PROJECT_ROOT";
 var CONFIG_PATH2 = ".story/config.json";
-var version = "1.4.2";
+var version = "1.4.3";
 function tryDiscoverRoot() {
   const envRoot = process.env[ENV_VAR2] ?? process.env[LEGACY_ENV_VAR2];
   const envName = process.env[ENV_VAR2] ? ENV_VAR2 : LEGACY_ENV_VAR2;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storybloq/storybloq",
-  "version": "1.4.2",
+  "version": "1.4.3",
   "license": "PolyForm-Noncommercial-1.0.0",
   "description": "Project memory for Claude Code. Storybloq stores tickets, issues, handovers, and lessons in a .story/ folder inside your repo so every session starts where the last one left off. Pairs with the Storybloq Mac app on the App Store.",
   "homepage": "https://storybloq.com",