tmux-ide 2.1.5 → 2.6.1

package/scripts/capture-codex-traffic.mjs

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = join(__dirname, "..");
+const fixturesDir = join(root, "packages/daemon/src/codex/__fixtures__");
+const prompts = [
+  { name: "turn-pong.ndjson", text: "PONG" },
+  { name: "turn-2plus2.ndjson", text: "what's 2+2" },
+  { name: "turn-ls-tmp.ndjson", text: "list /tmp briefly" },
+];
+
+let nextId = 1;
+const pending = new Map();
+const notifications = new Set();
+let child;
+let buffer = "";
+
+function fail(message) {
+  console.error(`[capture-codex-traffic] ${message}`);
+  process.exit(1);
+}
+
+function write(payload) {
+  child.stdin.write(`${JSON.stringify(payload)}\n`);
+}
+
+function request(method, params, timeoutMs = 30_000) {
+  const id = nextId++;
+  write({ id, method, params });
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      pending.delete(id);
+      reject(new Error(`Timed out waiting for ${method}`));
+    }, timeoutMs);
+    pending.set(id, { resolve, reject, timer, method });
+  });
+}
+
+function notify(method, params) {
+  write({ method, params });
+}
+
+function isTerminalTurnEvent(frame) {
+  if (frame.method === "turn/completed") return true;
+  if (frame.method === "item/completed") {
+    const item = frame.params?.item;
+    const type = item?.type ?? item?.item?.type;
+    const phase = item?.phase ?? item?.status ?? item?.item?.phase ?? item?.item?.status;
+    return type === "agentMessage" && (phase === "final" || phase === "completed");
+  }
+  if (frame.method === "rawResponseItem/completed") {
+    const item = frame.params?.item;
+    const type = item?.type;
+    const status = item?.status;
+    return type === "message" && status === "completed";
+  }
+  return false;
+}
+
+function handleServerRequest(frame) {
+  if (frame.method === "account/chatgptAuthTokens/refresh") {
+    write({
+      id: frame.id,
+      error: { code: -32603, message: "Token refresh is not available in capture script" },
+    });
+    return;
+  }
+  if (frame.method === "applyPatchApproval") {
+    write({ id: frame.id, result: { decision: "denied" } });
+    return;
+  }
+  write({ id: frame.id, error: { code: -32601, message: `Unhandled request: ${frame.method}` } });
+}
+
+function handleFrame(frame) {
+  if (frame.id !== undefined && frame.method === undefined) {
+    const next = pending.get(frame.id);
+    if (!next) return;
+    clearTimeout(next.timer);
+    pending.delete(frame.id);
+    if (frame.error) next.reject(new Error(`${next.method} failed: ${frame.error.message}`));
+    else next.resolve(frame.result);
+    return;
+  }
+  if (frame.id !== undefined && typeof frame.method === "string") {
+    handleServerRequest(frame);
+    return;
+  }
+  if (typeof frame.method === "string") {
+    for (const listener of notifications) listener(frame);
+  }
+}
+
+function handleChunk(chunk) {
+  buffer += chunk.toString("utf8");
+  for (;;) {
+    const newline = buffer.indexOf("\n");
+    if (newline === -1) break;
+    const line = buffer.slice(0, newline).trim();
+    buffer = buffer.slice(newline + 1);
+    if (!line) continue;
+    try {
+      handleFrame(JSON.parse(line));
+    } catch (err) {
+      fail(`Invalid JSON from codex: ${err.message}\n${line}`);
+    }
+  }
+}
+
+function captureTurn(prompt) {
+  const frames = [];
+  let sawTerminal = false;
+  let quietTimer;
+  let hardTimer;
+
+  return new Promise((resolve, reject) => {
+    function finish() {
+      clearTimeout(quietTimer);
+      clearTimeout(hardTimer);
+      notifications.delete(onNotification);
+      resolve(frames);
+    }
+    function onNotification(frame) {
+      frames.push(frame);
+      if (isTerminalTurnEvent(frame)) sawTerminal = true;
+      clearTimeout(quietTimer);
+      quietTimer = setTimeout(() => {
+        if (sawTerminal) finish();
+      }, 1_500);
+    }
+
+    hardTimer = setTimeout(() => {
+      notifications.delete(onNotification);
+      reject(new Error(`Timed out capturing turn for ${prompt.name}`));
+    }, 120_000);
+    notifications.add(onNotification);
+  });
+}
+
+async function main() {
+  child = spawn("codex", ["app-server"], {
+    cwd: root,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+  child.stdout.on("data", handleChunk);
+  child.stderr.on("data", (chunk) => process.stderr.write(chunk));
+  child.on("error", (err) => fail(`Failed to spawn codex app-server: ${err.message}`));
+
+  await new Promise((resolve, reject) => {
+    child.once("spawn", resolve);
+    child.once("exit", (code, signal) =>
+      reject(new Error(`codex exited early: ${code ?? signal}`)),
+    );
+    child.once("error", reject);
+  }).catch((err) => fail(err.message));
+
+  try {
+    await request("initialize", {
+      clientInfo: { name: "tmux-ide-capture", title: "tmux-ide capture", version: "0.0.1" },
+      capabilities: { experimentalApi: true, optOutNotificationMethods: null },
+    });
+    notify("initialized", {});
+    const conversation = await request("thread/start", {
+      cwd: root,
+      approvalPolicy: "never",
+      sandbox: "danger-full-access",
+      sessionStartSource: "startup",
+    });
+    const threadId = conversation.thread.id;
+
+    mkdirSync(fixturesDir, { recursive: true });
+    for (const prompt of prompts) {
+      const captured = captureTurn(prompt);
+      await request("turn/start", {
+        threadId,
+        input: [{ type: "text", text: prompt.text }],
+        approvalPolicy: "never",
+      });
+      const frames = await captured;
+      writeFileSync(
+        join(fixturesDir, prompt.name),
+        `${frames.map((f) => JSON.stringify(f)).join("\n")}\n`,
+      );
+      console.error(`[capture-codex-traffic] wrote ${prompt.name} (${frames.length} frames)`);
+    }
+  } finally {
+    child.kill("SIGTERM");
+  }
+}
+
+main().catch((err) => fail(err.message));

package/scripts/check-src-additions.sh

@@ -0,0 +1,74 @@
+#!/usr/bin/env bash
+# Block new files under repo-root src/.
+#
+# Why: src/ is frozen — every consumer migrated to packages/* (T039–T041,
+# T056). Adding new code there resurrects the divergent-tree problem the
+# T060 work ended.  See ARCHITECTURE.md for the full rule and the canonical
+# decision tree.
+#
+# Usage:
+#   - Pre-commit hook: invoked with no args; checks the staged-add set.
+#   - CI: pass a base ref as $1 (e.g. origin/main) to check the diff range.
+#   - Manual: `bash scripts/check-src-additions.sh origin/main` for a dry run.
+#
+# Allow-list: any path listed in .src-allowlist (one path per line, blank
+# lines and `#`-comments ignored) is permitted. Keep the list small and
+# shrinking — every line is a deletion target.
+
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+ALLOWLIST="$REPO_ROOT/.src-allowlist"
+
+# Resolve the file set to inspect.
+if [ "$#" -ge 1 ] && [ -n "$1" ]; then
+  # CI / manual: diff vs the supplied base ref.
+  base="$1"
+  added="$(git -C "$REPO_ROOT" diff --diff-filter=A --name-only "$base"...HEAD -- 'src/**' 2>/dev/null || true)"
+else
+  # Pre-commit: only the staged-add set.
+  added="$(git -C "$REPO_ROOT" diff --diff-filter=A --cached --name-only -- 'src/**' 2>/dev/null || true)"
+fi
+
+# Filter against allow-list.
+filtered=""
+if [ -n "$added" ]; then
+  if [ -f "$ALLOWLIST" ]; then
+    while IFS= read -r path; do
+      [ -z "$path" ] && continue
+      # Skip lines whose first non-whitespace char is `#`.
+      case "$path" in
+        \#*|" "*"#"*) continue ;;
+      esac
+      if ! grep -Fxq "$path" "$ALLOWLIST"; then
+        filtered+="$path"$'\n'
+      fi
+    done <<< "$added"
+  else
+    filtered="$added"$'\n'
+  fi
+fi
+
+# Trim trailing newline + any blank lines.
+filtered="$(printf '%s' "$filtered" | sed '/^$/d')"
+
+if [ -n "$filtered" ]; then
+  cat >&2 <<EOF
+ERROR: new files added under repo-root src/ are not allowed.
+
+src/ is frozen — every canonical home for new code lives under packages/*.
+See ARCHITECTURE.md ("Decision tree: where does new code go?") for the right
+package, and ARCHITECTURE.md ("How guardrails enforce this") for context on
+this check (T060).
+
+Offending files:
+$filtered
+
+If a single path genuinely needs to be carved out (rare — usually a transient
+shim during a migration), add it to .src-allowlist with a one-line comment
+explaining why and link the follow-up issue/task that will delete it.
+EOF
+  exit 1
+fi
+
+exit 0

package/scripts/coverage-summary.mjs

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+/**
+ * Read every package's `coverage/coverage-summary.json` (vitest's
+ * `json-summary` reporter) and emit a single GitHub-flavored markdown
+ * table to stdout. CI pipes the output into `$GITHUB_STEP_SUMMARY` so
+ * the result lands on the PR's checks page without needing a bot
+ * comment.
+ *
+ * No dependencies — runs under the same Node the CI step bootstrapped.
+ */
+
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+const ROOT = process.cwd();
+
+const PACKAGES = [{ name: "daemon", dir: "packages/daemon", target: 70 }];
+
+function readSummary(pkgDir) {
+  const path = join(ROOT, pkgDir, "coverage", "coverage-summary.json");
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+function pct(n) {
+  if (typeof n !== "number" || Number.isNaN(n)) return "—";
+  return `${n.toFixed(1)}%`;
+}
+
+function badge(actualPct, targetPct) {
+  if (typeof actualPct !== "number") return "❔";
+  if (actualPct >= targetPct) return "✅";
+  if (actualPct >= targetPct - 5) return "🟡";
+  return "🔻";
+}
+
+function row(pkg, summary) {
+  if (!summary || !summary.total) {
+    return `| **${pkg.name}** | _no report_ | — | — | — | — | — |`;
+  }
+  const t = summary.total;
+  const lines = t.lines?.pct;
+  const stmts = t.statements?.pct;
+  const funcs = t.functions?.pct;
+  const branches = t.branches?.pct;
+  return `| **${pkg.name}** | ${badge(lines, pkg.target)} ${pct(lines)} / ${pkg.target}% | ${pct(stmts)} | ${pct(funcs)} | ${pct(branches)} | _see HTML artifact_ |`;
+}
+
+const rows = PACKAGES.map((pkg) => row(pkg, readSummary(pkg.dir)));
+
+const out = [
+  "## 📊 Vitest coverage",
+  "",
+  "Per-package coverage, scoped to the files exercised by each test harness.",
+  "Lines column shows actual / target; ✅ = at-or-above target, 🟡 = within 5 pts, 🔻 = below floor.",
+  "",
+  "| Package | Lines | Statements | Functions | Branches | Notes |",
+  "|---|---|---|---|---|---|",
+  ...rows,
+  "",
+  "<sub>HTML reports uploaded as the `coverage-html` artifact.</sub>",
+];
+
+process.stdout.write(out.join("\n") + "\n");

package/scripts/install-git-hooks.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+// Install the local pre-commit hook that blocks new files under
+// repo-root src/. Idempotent — safe to run on every pnpm install.
+//
+// Skips silently when:
+//   - run from a published package (not a git checkout) — no .git dir
+//   - INSTALL_GIT_HOOKS=0 in the environment
+
+import { mkdirSync, writeFileSync, readFileSync, chmodSync, statSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+
+if (process.env.INSTALL_GIT_HOOKS === "0") process.exit(0);
+
+const repoRoot = resolve(dirname(import.meta.dirname));
+const gitDir = resolve(repoRoot, ".git");
+
+let isGitCheckout = false;
+try {
+  isGitCheckout = statSync(gitDir).isDirectory();
+} catch {
+  /* not a git checkout */
+}
+if (!isGitCheckout) process.exit(0);
+
+const hooksDir = resolve(gitDir, "hooks");
+mkdirSync(hooksDir, { recursive: true });
+
+const hookPath = resolve(hooksDir, "pre-commit");
+const hookBody = [
+  "#!/usr/bin/env bash",
+  "# Managed by scripts/install-git-hooks.js — edits here will be overwritten.",
+  "# Edit scripts/check-src-additions.sh for the actual check logic.",
+  "",
+  "set -e",
+  `"${repoRoot}/scripts/check-src-additions.sh"`,
+  "",
+].join("\n");
+
+let existing = null;
+try {
+  existing = readFileSync(hookPath, "utf8");
+} catch {
+  /* no existing hook */
+}
+
+if (existing === hookBody) {
+  // Already up-to-date.
+  process.exit(0);
+}
+
+writeFileSync(hookPath, hookBody);
+chmodSync(hookPath, 0o755);
+console.log("[tmux-ide] installed .git/hooks/pre-commit (blocks new files in src/)");

package/scripts/merge-update-manifests.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync } from "node:fs";
+import yaml from "js-yaml";
+
+const [, , primaryPath, secondaryPath, outputPath] = process.argv;
+
+if (!primaryPath || !secondaryPath || !outputPath) {
+  console.error("Usage: merge-update-manifests <primary.yml> <secondary.yml> <output.yml>");
+  process.exit(2);
+}
+
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+function readManifest(filePath) {
+  const manifest = yaml.load(readFileSync(filePath, "utf-8"));
+  if (!manifest || typeof manifest !== "object") {
+    fail(`Invalid manifest: ${filePath}`);
+  }
+  if (!Array.isArray(manifest.files)) {
+    fail(`Missing files array: ${filePath}`);
+  }
+  return manifest;
+}
+
+const primary = readManifest(primaryPath);
+const secondary = readManifest(secondaryPath);
+
+if (primary.version !== secondary.version) {
+  fail(`Version mismatch: ${primary.version} vs ${secondary.version}`);
+}
+
+if (primary.releaseDate !== secondary.releaseDate) {
+  fail(`Release date mismatch: ${primary.releaseDate} vs ${secondary.releaseDate}`);
+}
+
+const seenUrls = new Set();
+const mergedFiles = [];
+
+for (const entry of [...primary.files, ...secondary.files]) {
+  if (!entry || typeof entry.url !== "string") continue;
+  const existing = seenUrls.has(entry.url);
+  if (existing) continue;
+  seenUrls.add(entry.url);
+  mergedFiles.push(entry);
+}
+
+if (mergedFiles.length === 0) {
+  fail("Merged manifest has no files");
+}
+
+const merged = { ...primary, files: mergedFiles };
+writeFileSync(outputPath, yaml.dump(merged, { lineWidth: -1 }));
+console.log(
+  `Merged ${primaryPath} + ${secondaryPath} -> ${outputPath} (${mergedFiles.length} files)`,
+);

package/scripts/merge-update-manifests.test.mjs

@@ -0,0 +1,82 @@
+import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import yaml from "js-yaml";
+
+const scriptPath = new URL("./merge-update-manifests.mjs", import.meta.url).pathname;
+
+function tempDir() {
+  return mkdtempSync(path.join(os.tmpdir(), "tmux-ide-manifest-test-"));
+}
+
+function writeManifest(dir, name, manifest) {
+  const filePath = path.join(dir, name);
+  writeFileSync(filePath, yaml.dump(manifest, { lineWidth: -1 }));
+  return filePath;
+}
+
+function runMerge(primary, secondary, output) {
+  return spawnSync(process.execPath, [scriptPath, primary, secondary, output], {
+    encoding: "utf-8",
+  });
+}
+
+const baseManifest = {
+  version: "0.1.0",
+  releaseDate: "2026-05-05T00:00:00.000Z",
+  path: "tmux-ide-0.1.0-arm64.zip",
+  sha512: "primary-sha",
+  files: [{ url: "tmux-ide-0.1.0-arm64.zip", sha512: "primary-sha", size: 10 }],
+};
+
+describe("merge-update-manifests", () => {
+  it("writes a manifest containing both architecture file entries", () => {
+    const dir = tempDir();
+    const primary = writeManifest(dir, "latest-mac-arm64.yml", baseManifest);
+    const secondary = writeManifest(dir, "latest-mac-x64.yml", {
+      ...baseManifest,
+      path: "tmux-ide-0.1.0-x64.zip",
+      sha512: "secondary-sha",
+      files: [{ url: "tmux-ide-0.1.0-x64.zip", sha512: "secondary-sha", size: 20 }],
+    });
+    const output = path.join(dir, "latest-mac.yml");
+
+    const result = runMerge(primary, secondary, output);
+    assert.equal(result.status, 0, result.stderr);
+
+    const merged = yaml.load(readFileSync(output, "utf-8"));
+    assert.equal(merged.version, "0.1.0");
+    assert.deepEqual(
+      merged.files.map((file) => file.url),
+      ["tmux-ide-0.1.0-arm64.zip", "tmux-ide-0.1.0-x64.zip"],
+    );
+  });
+
+  it("exits non-zero on version mismatch", () => {
+    const dir = tempDir();
+    const primary = writeManifest(dir, "primary.yml", baseManifest);
+    const secondary = writeManifest(dir, "secondary.yml", { ...baseManifest, version: "0.2.0" });
+    const result = runMerge(primary, secondary, path.join(dir, "out.yml"));
+
+    assert.notEqual(result.status, 0);
+    assert.match(result.stderr, /Version mismatch/);
+  });
+
+  it("deduplicates duplicate file URLs", () => {
+    const dir = tempDir();
+    const primary = writeManifest(dir, "primary.yml", baseManifest);
+    const secondary = writeManifest(dir, "secondary.yml", {
+      ...baseManifest,
+      files: [...baseManifest.files],
+    });
+    const output = path.join(dir, "out.yml");
+
+    const result = runMerge(primary, secondary, output);
+    assert.equal(result.status, 0, result.stderr);
+    const merged = yaml.load(readFileSync(output, "utf-8"));
+    assert.equal(merged.files.length, 1);
+  });
+});

package/scripts/pack-check-run.mjs

@@ -0,0 +1,83 @@
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, mkdtempSync, mkdirSync, readdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const root = process.cwd();
+const tmpRoot = mkdtempSync(join(tmpdir(), "tmux-ide-pack-run-"));
+const tarballDir = join(tmpRoot, "tarballs");
+const projectDir = join(tmpRoot, "project");
+const homeDir = join(tmpRoot, "home");
+mkdirSync(tarballDir, { recursive: true });
+mkdirSync(projectDir, { recursive: true });
+mkdirSync(homeDir, { recursive: true });
+
+function run(command, args, opts = {}) {
+  const res = spawnSync(command, args, {
+    cwd: opts.cwd ?? root,
+    env: { ...process.env, HOME: homeDir, npm_config_cache: join(tmpRoot, "npm-cache") },
+    encoding: "utf-8",
+    stdio: opts.stdio ?? "pipe",
+  });
+  if (res.status !== 0) {
+    throw new Error(
+      `${command} ${args.join(" ")} failed\n${res.stdout ?? ""}\n${res.stderr ?? ""}`,
+    );
+  }
+  return res;
+}
+
+function findTarball(prefix, excludePrefix = null) {
+  const match = readdirSync(tarballDir).find(
+    (file) =>
+      file.startsWith(prefix) &&
+      (!excludePrefix || !file.startsWith(excludePrefix)) &&
+      file.endsWith(".tgz"),
+  );
+  if (!match) throw new Error(`No tarball found for ${prefix}`);
+  return join(tarballDir, match);
+}
+
+let child = null;
+try {
+  run("pnpm", ["--dir", "packages/daemon", "pack", "--pack-destination", tarballDir], {
+    stdio: "inherit",
+  });
+  run("pnpm", ["pack", "--pack-destination", tarballDir], { stdio: "inherit" });
+
+  const daemonTarball = findTarball("tmux-ide-daemon-");
+  const rootTarball = findTarball("tmux-ide-", "tmux-ide-daemon-");
+  run("npm", ["init", "-y"], { cwd: projectDir });
+  run("npm", ["install", daemonTarball, rootTarball], { cwd: projectDir, stdio: "inherit" });
+
+  run("npx", ["tmux-ide", "--version"], { cwd: projectDir, stdio: "inherit" });
+
+  child = spawn("npx", ["tmux-ide", "--headless"], {
+    cwd: projectDir,
+    env: { ...process.env, HOME: homeDir, npm_config_cache: join(tmpRoot, "npm-cache") },
+    stdio: "ignore",
+    detached: true,
+  });
+
+  const daemonInfo = join(homeDir, ".tmux-ide", "daemon.json");
+  const deadline = Date.now() + 10_000;
+  while (!existsSync(daemonInfo) && Date.now() < deadline) {
+    await new Promise((resolveDelay) => setTimeout(resolveDelay, 150));
+  }
+  if (!existsSync(daemonInfo)) throw new Error("Headless daemon did not write daemon.json");
+
+  run("npx", ["tmux-ide", "task", "list"], { cwd: projectDir, stdio: "inherit" });
+} finally {
+  if (child?.pid) {
+    try {
+      process.kill(-child.pid, "SIGTERM");
+    } catch {
+      try {
+        process.kill(child.pid, "SIGTERM");
+      } catch {
+        // Already exited.
+      }
+    }
+  }
+  rmSync(tmpRoot, { recursive: true, force: true });
+}

package/scripts/postinstall.js

@@ -1,17 +1,63 @@
-import { existsSync, mkdirSync, copyFileSync, readFileSync, writeFileSync } from "node:fs";
-import { resolve, dirname } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, symlinkSync } from "node:fs";
+import { resolve, dirname, relative } from "node:path";
 import { homedir } from "node:os";
 
+// ---------------------------------------------------------------------------
+// Workspace-package links — MUST run before the Claude gate below.
+//
+// The TUI sources (packages/daemon/src/**, run via bun) import the workspace
+// packages @tmux-ide/tmux-bridge and @tmux-ide/contracts. In a dev checkout
+// pnpm symlinks them into node_modules; an npm install has no such links, so
+// recreate them (their package.json mains point at shipped src/index.ts,
+// which bun runs directly). Best-effort: never fail an install.
+// ---------------------------------------------------------------------------
+try {
+  const pkgRoot = dirname(import.meta.dirname);
+  const scopeDir = resolve(pkgRoot, "node_modules", "@tmux-ide");
+  for (const name of ["tmux-bridge", "contracts"]) {
+    const target = resolve(pkgRoot, "packages", name);
+    const link = resolve(scopeDir, name);
+    if (!existsSync(target) || existsSync(link)) continue;
+    mkdirSync(scopeDir, { recursive: true });
+    // "junction" keeps Windows working without admin; ignored elsewhere.
+    symlinkSync(relative(scopeDir, target), link, "junction");
+  }
+} catch {
+  // linking is best-effort; the CLI's TUI fallback message covers the gap
+}
+
 const claudeDir = resolve(homedir(), ".claude");
 if (!shouldInstallClaudeIntegration() || !existsSync(claudeDir)) {
   process.exit(0);
 }
 
-const skillDir = resolve(claudeDir, "skills", "tmux-ide");
-mkdirSync(skillDir, { recursive: true });
-const src = resolve(dirname(import.meta.dirname), "skill", "SKILL.md");
-if (existsSync(src)) {
-  copyFileSync(src, resolve(skillDir, "SKILL.md"));
+// Sync the bundled Claude Code skill into ~/.claude/skills/tmux-ide, rewriting
+// its version marker to the installed package version. This is the JS twin of
+// packages/daemon/src/lib/skill-sync.ts (syncSkill) — postinstall runs under
+// stock node before any build, so it can't import the TS module; keep the marker
+// regex in sync with VERSION_MARKER_RE there. Best-effort: never fail an install.
+try {
+  const pkgRoot = dirname(import.meta.dirname);
+  const src = resolve(pkgRoot, "skill", "SKILL.md");
+  if (existsSync(src)) {
+    const skillDir = resolve(claudeDir, "skills", "tmux-ide");
+    mkdirSync(skillDir, { recursive: true });
+    let content = readFileSync(src, "utf-8");
+    try {
+      const { version } = JSON.parse(readFileSync(resolve(pkgRoot, "package.json"), "utf-8"));
+      if (typeof version === "string" && version.length > 0) {
+        content = content.replace(
+          /<!--\s*tmux-ide-skill-version:\s*[^\s]+\s*-->/,
+          `<!-- tmux-ide-skill-version: ${version} -->`,
+        );
+      }
+    } catch {
+      // couldn't read the version — copy the skill verbatim
+    }
+    writeFileSync(resolve(skillDir, "SKILL.md"), content);
+  }
+} catch {
+  // skill sync is best-effort; a failure must not break the install
 }
 
 const settingsPath = resolve(claudeDir, "settings.json");