@solaqua/gji 0.11.0 → 0.12.0

package/dist/gji-bundle.mjs

@@ -3951,8 +3951,8 @@ var require_graceful_fs = __commonJS({
       fs6.createReadStream = createReadStream;
       fs6.createWriteStream = createWriteStream;
       var fs$readFile = fs6.readFile;
-      fs6.readFile = readFile10;
-      function readFile10(path9, options, cb) {
+      fs6.readFile = readFile12;
+      function readFile12(path9, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path9, options, cb);
@@ -3968,8 +3968,8 @@ var require_graceful_fs = __commonJS({
         }
       }
       var fs$writeFile = fs6.writeFile;
-      fs6.writeFile = writeFile10;
-      function writeFile10(path9, data, options, cb) {
+      fs6.writeFile = writeFile12;
+      function writeFile12(path9, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$writeFile(path9, data, options, cb);
@@ -5386,7 +5386,7 @@ var require_minimist = __commonJS({
 var require_rc = __commonJS({
   "node_modules/.pnpm/rc@1.2.8/node_modules/rc/index.js"(exports, module) {
     var cc = require_utils();
-    var join17 = __require("path").join;
+    var join19 = __require("path").join;
     var deepExtend = require_deep_extend();
     var etc = "/etc";
     var win = process.platform === "win32";
@@ -5411,15 +5411,15 @@ var require_rc = __commonJS({
       }
       if (!win)
         [
-          join17(etc, name, "config"),
-          join17(etc, name + "rc")
+          join19(etc, name, "config"),
+          join19(etc, name + "rc")
         ].forEach(addConfigFile);
       if (home)
         [
-          join17(home, ".config", name, "config"),
-          join17(home, ".config", name),
-          join17(home, "." + name, "config"),
-          join17(home, "." + name + "rc")
+          join19(home, ".config", name, "config"),
+          join19(home, ".config", name),
+          join19(home, "." + name, "config"),
+          join19(home, "." + name + "rc")
         ].forEach(addConfigFile);
       addConfigFile(cc.find("." + name + "rc"));
       if (env5.config) addConfigFile(env5.config);
@@ -5925,8 +5925,8 @@ var require_graceful_fs2 = __commonJS({
       fs6.createReadStream = createReadStream;
       fs6.createWriteStream = createWriteStream;
       var fs$readFile = fs6.readFile;
-      fs6.readFile = readFile10;
-      function readFile10(path9, options, cb) {
+      fs6.readFile = readFile12;
+      function readFile12(path9, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path9, options, cb);
@@ -5942,8 +5942,8 @@ var require_graceful_fs2 = __commonJS({
         }
       }
       var fs$writeFile = fs6.writeFile;
-      fs6.writeFile = writeFile10;
-      function writeFile10(path9, data, options, cb) {
+      fs6.writeFile = writeFile12;
+      function writeFile12(path9, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$writeFile(path9, data, options, cb);
@@ -6757,11 +6757,11 @@ var require_util = __commonJS({
           if (files.includes("node_modules") || files.includes("package.json") || files.includes("package.json5") || files.includes("package.yaml") || files.includes("pnpm-workspace.yaml")) {
             return name2;
           }
-          const dirname13 = path9.dirname(name2);
-          if (dirname13 === name2) {
+          const dirname14 = path9.dirname(name2);
+          if (dirname14 === name2) {
             return original;
           }
-          return find(dirname13, original);
+          return find(dirname14, original);
         } catch (error) {
           if (name2 === original) {
             if (error.code === "ENOENT") {
@@ -9422,7 +9422,7 @@ var require_picocolors = __commonJS({
 });
 
 // src/index.ts
-import { homedir as homedir10 } from "node:os";
+import { homedir as homedir11 } from "node:os";
 
 // src/cli.ts
 import { createRequire } from "node:module";
@@ -9522,7 +9522,7 @@ var retryifyAsync = (fn, options) => {
           throw error;
         const delay2 = Math.round(interval * Math.random());
         if (delay2 > 0) {
-          const delayPromise = new Promise((resolve12) => setTimeout(resolve12, delay2));
+          const delayPromise = new Promise((resolve13) => setTimeout(resolve13, delay2));
           return delayPromise.then(() => attempt.apply(void 0, args));
         } else {
           return attempt.apply(void 0, args);
@@ -9781,14 +9781,14 @@ var Temp = {
     }
   },
   truncate: (filePath) => {
-    const basename11 = path2.basename(filePath);
-    if (basename11.length <= LIMIT_BASENAME_LENGTH)
+    const basename12 = path2.basename(filePath);
+    if (basename12.length <= LIMIT_BASENAME_LENGTH)
       return filePath;
-    const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename11);
+    const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename12);
     if (!truncable)
       return filePath;
-    const truncationLength = basename11.length - LIMIT_BASENAME_LENGTH;
-    return `${filePath.slice(0, -basename11.length)}${truncable[1]}${truncable[2].slice(0, -truncationLength)}${truncable[3]}`;
+    const truncationLength = basename12.length - LIMIT_BASENAME_LENGTH;
+    return `${filePath.slice(0, -basename12.length)}${truncable[1]}${truncable[2].slice(0, -truncationLength)}${truncable[3]}`;
   }
 };
 node_default(Temp.purgeSyncAll);
@@ -11088,14 +11088,14 @@ var TimeoutError = class extends Error {
 
 // node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/utils/timeout.js
 async function timeout(request, init, abortController, options) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     const timeoutId = setTimeout(() => {
       if (abortController) {
         abortController.abort();
       }
       reject(new TimeoutError(request));
     }, options.timeout);
-    void options.fetch(request, init).then(resolve12).catch(reject).then(() => {
+    void options.fetch(request, init).then(resolve13).catch(reject).then(() => {
       clearTimeout(timeoutId);
     });
   });
@@ -11103,7 +11103,7 @@ async function timeout(request, init, abortController, options) {
 
 // node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/utils/delay.js
 async function delay(ms, { signal }) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     if (signal) {
       signal.throwIfAborted();
       signal.addEventListener("abort", abortHandler, { once: true });
@@ -11114,7 +11114,7 @@ async function delay(ms, { signal }) {
     }
     const timeoutId = setTimeout(() => {
       signal?.removeEventListener("abort", abortHandler);
-      resolve12();
+      resolve13();
     }, ms);
   });
 }
@@ -13219,7 +13219,7 @@ async function runArgvHook(hookCmd, cwd, context, stderr, stdout2) {
     stderr("gji: hook argv command must include a non-empty command\n");
     return;
   }
-  await new Promise((resolve12) => {
+  await new Promise((resolve13) => {
     const child = spawn2(command, args, {
       cwd,
       shell: false,
@@ -13239,18 +13239,18 @@ async function runArgvHook(hookCmd, cwd, context, stderr, stdout2) {
 `
         );
       }
-      resolve12();
+      resolve13();
     });
     child.on("error", (err) => {
       stderr(`gji: hook failed to start: ${err.message}
 `);
-      resolve12();
+      resolve13();
     });
   });
 }
 async function runShellHook(hookCmd, cwd, context, stderr, stdout2) {
   const interpolated = interpolate(hookCmd, context);
-  await new Promise((resolve12) => {
+  await new Promise((resolve13) => {
     const child = spawn2(interpolated, {
       cwd,
       shell: true,
@@ -13268,12 +13268,12 @@ async function runShellHook(hookCmd, cwd, context, stderr, stdout2) {
         stderr(`gji: hook exited with code ${code}: ${interpolated}
 `);
       }
-      resolve12();
+      resolve13();
     });
     child.on("error", (err) => {
       stderr(`gji: hook failed to start: ${err.message}
 `);
-      resolve12();
+      resolve13();
     });
   });
 }
@@ -13282,14 +13282,18 @@ function hookEnvironment(context) {
     ...process.env,
     GJI_BRANCH: context.branch ?? "",
     GJI_PATH: context.path,
-    GJI_REPO: context.repo
+    GJI_REPO: context.repo,
+    ...context.slot === null || context.slot === void 0 ? {} : { GJI_SLOT: String(context.slot) }
   };
 }
 function formatArgvHook(command, args) {
   return JSON.stringify([command, ...args]);
 }
 function interpolate(template, context) {
-  return template.replace(/\{\{branch\}\}/g, context.branch ?? "").replace(/\{\{path\}\}/g, context.path).replace(/\{\{repo\}\}/g, context.repo);
+  return template.replace(/\{\{branch\}\}/g, context.branch ?? "").replace(/\{\{path\}\}/g, context.path).replace(/\{\{repo\}\}/g, context.repo).replace(
+    /\{\{slot\}\}/g,
+    context.slot === null || context.slot === void 0 ? "" : String(context.slot)
+  );
 }
 function extractHooks(config) {
   const raw = config.hooks;
@@ -13486,6 +13490,10 @@ async function detectRepository(cwd) {
     repoRoot
   };
 }
+async function worktreeGitDir(worktreePath) {
+  const rawGitDir = await runGit(worktreePath, ["rev-parse", "--git-dir"]);
+  return isAbsolute2(rawGitDir) ? rawGitDir : resolve3(worktreePath, rawGitDir);
+}
 function resolveWorktreePath(repoRoot, branch, basePath) {
   const segments = branch.split("/").filter(Boolean);
   if (segments.length === 0) {
@@ -14277,42 +14285,98 @@ function isHeadless() {
   return process.env.GJI_NO_TUI === "1";
 }
 
+// src/slots.ts
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile4 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname4, join as join4, resolve as resolve4 } from "node:path";
+function SLOTS_FILE_PATH(home = homedir4()) {
+  const configDir = process.env.GJI_CONFIG_DIR;
+  return configDir ? join4(resolve4(configDir), "slots.json") : join4(home, GLOBAL_CONFIG_DIRECTORY, "slots.json");
+}
+async function loadSlots(home = homedir4()) {
+  try {
+    const parsed = JSON.parse(
+      await readFile3(SLOTS_FILE_PATH(home), "utf8")
+    );
+    if (!isSlotStore(parsed)) return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+async function assignWorktreeSlot(repoRoot, worktreePath, home = homedir4()) {
+  const slots = await loadSlots(home);
+  const existing = slots[worktreePath];
+  if (existing !== void 0) return existing;
+  if (worktreePath !== repoRoot && slots[repoRoot] === void 0)
+    slots[repoRoot] = 0;
+  const used = new Set(Object.values(slots));
+  const slot = worktreePath === repoRoot ? 0 : nextAvailableSlot(used);
+  slots[worktreePath] = slot;
+  await saveSlots(slots, home);
+  return slot;
+}
+async function getWorktreeSlot(worktreePath, home = homedir4()) {
+  const slot = (await loadSlots(home))[worktreePath];
+  return slot === void 0 ? null : slot;
+}
+async function releaseWorktreeSlot(worktreePath, home = homedir4()) {
+  const slots = await loadSlots(home);
+  if (!(worktreePath in slots)) return;
+  delete slots[worktreePath];
+  await saveSlots(slots, home);
+}
+async function saveSlots(slots, home) {
+  const path9 = SLOTS_FILE_PATH(home);
+  await mkdir3(dirname4(path9), { recursive: true });
+  await writeFile4(path9, `${JSON.stringify(slots, null, 2)}
+`, "utf8");
+}
+function nextAvailableSlot(used) {
+  let slot = 1;
+  while (used.has(slot)) slot += 1;
+  return slot;
+}
+function isSlotStore(value) {
+  return typeof value === "object" && value !== null && Object.values(value).every((slot) => Number.isInteger(slot) && slot >= 0);
+}
+
 // src/undo.ts
 import {
   access as access3,
-  mkdir as mkdir3,
+  mkdir as mkdir4,
   open,
-  readFile as readFile3,
+  readFile as readFile4,
   rename,
   stat,
   unlink,
-  writeFile as writeFile4
+  writeFile as writeFile5
 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname4, join as join4, resolve as resolve4 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname5, join as join5, resolve as resolve5 } from "node:path";
 var MAX_UNDO_RECORDS = 20;
 var UNDO_LOCK_STALE_AFTER_MS = 6e4;
 var UNDO_LOCK_RETRY_DELAY_MS = 5;
 var UNDO_LOCK_WAIT_TIMEOUT_MS = UNDO_LOCK_STALE_AFTER_MS + UNDO_LOCK_RETRY_DELAY_MS;
 var undoLogQueues = /* @__PURE__ */ new Map();
-function undoLogPath(home = homedir4()) {
+function undoLogPath(home = homedir5()) {
   const configured = process.env.GJI_CONFIG_DIR;
-  return join4(
-    configured ? resolve4(configured) : join4(home, GLOBAL_CONFIG_DIRECTORY),
+  return join5(
+    configured ? resolve5(configured) : join5(home, GLOBAL_CONFIG_DIRECTORY),
     "undo-log.json"
   );
 }
-async function loadUndoRecords(home = homedir4()) {
+async function loadUndoRecords(home = homedir5()) {
   try {
     const parsed = JSON.parse(
-      await readFile3(undoLogPath(home), "utf8")
+      await readFile4(undoLogPath(home), "utf8")
     );
     return Array.isArray(parsed) ? parsed.filter(isUndoRecord) : [];
   } catch {
     return [];
   }
 }
-async function recordUndoOperation(op, repoRoot, worktrees, home = homedir4()) {
+async function recordUndoOperation(op, repoRoot, worktrees, home = homedir5()) {
   const entries = [];
   for (const worktree of worktrees) {
     try {
@@ -14355,7 +14419,7 @@ async function recordUndoOperation(op, repoRoot, worktrees, home = homedir4()) {
     return record;
   });
 }
-async function finalizeUndoOperation(record, removedWorktrees, home = homedir4()) {
+async function finalizeUndoOperation(record, removedWorktrees, home = homedir5()) {
   const removedPaths = new Set(
     removedWorktrees.map((worktree) => worktree.path)
   );
@@ -14371,7 +14435,7 @@ async function finalizeUndoOperation(record, removedWorktrees, home = homedir4()
     await writeUndoRecords(home, remaining);
   });
 }
-async function restoreUndoRecord(record, home = homedir4()) {
+async function restoreUndoRecord(record, home = homedir5()) {
   const restored = [];
   const failed = [];
   const unresolved = [];
@@ -14478,7 +14542,7 @@ async function runUndoCommand(options) {
 }
 async function hasMalformedUndoLog() {
   try {
-    const parsed = JSON.parse(await readFile3(undoLogPath(), "utf8"));
+    const parsed = JSON.parse(await readFile4(undoLogPath(), "utf8"));
     return !Array.isArray(parsed) || parsed.some((entry) => !isUndoRecord(entry));
   } catch (error) {
     return error instanceof Error && "code" in error && error.code !== "ENOENT";
@@ -14569,7 +14633,7 @@ async function assertCommitExists(repoRoot, headSha) {
 }
 async function enqueueUndoLogWrite(home, operation) {
   const path9 = undoLogPath(home);
-  await mkdir3(dirname4(path9), { recursive: true });
+  await mkdir4(dirname5(path9), { recursive: true });
   const previous = undoLogQueues.get(path9) ?? Promise.resolve();
   const runLocked = async () => {
     const release = await acquireUndoLogLock(path9);
@@ -14610,7 +14674,7 @@ async function acquireUndoLogLock(path9) {
       const remainingMs = deadline - Date.now();
       if (remainingMs > 0)
         await new Promise(
-          (resolve12) => setTimeout(resolve12, Math.min(UNDO_LOCK_RETRY_DELAY_MS, remainingMs))
+          (resolve13) => setTimeout(resolve13, Math.min(UNDO_LOCK_RETRY_DELAY_MS, remainingMs))
         );
     }
   }
@@ -14618,10 +14682,10 @@ async function acquireUndoLogLock(path9) {
 }
 async function writeUndoRecords(home, records) {
   const path9 = undoLogPath(home);
-  await mkdir3(dirname4(path9), { recursive: true });
+  await mkdir4(dirname5(path9), { recursive: true });
   const temporaryPath = `${path9}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    await writeFile4(temporaryPath, `${JSON.stringify(records, null, 2)}
+    await writeFile5(temporaryPath, `${JSON.stringify(records, null, 2)}
 `, {
       encoding: "utf8",
       flag: "wx"
@@ -14660,6 +14724,41 @@ function emitUndoError(options, message) {
   return 1;
 }
 
+// src/task.ts
+import { readFile as readFile5, unlink as unlink2, writeFile as writeFile6 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+async function readTask(worktreePath) {
+  try {
+    const parsed = JSON.parse(
+      await readFile5(await taskPath(worktreePath), "utf8")
+    );
+    return isTaskMetadata(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function writeTask(worktreePath, task, source = "manual") {
+  const metadata = { source, task, updatedAt: Date.now() };
+  const path9 = await taskPath(worktreePath);
+  await writeFile6(path9, `${JSON.stringify(metadata, null, 2)}
+`, "utf8");
+  return metadata;
+}
+async function clearTask(worktreePath) {
+  try {
+    await unlink2(await taskPath(worktreePath));
+  } catch {
+  }
+}
+async function taskPath(worktreePath) {
+  return join6(await worktreeGitDir(worktreePath), "gji-task.json");
+}
+function isTaskMetadata(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return typeof candidate.task === "string" && (candidate.source === "manual" || candidate.source === "pr") && typeof candidate.updatedAt === "number";
+}
+
 // src/worktree-info.ts
 var MAX_WORKTREE_INFO_READ_CONCURRENCY = 8;
 async function readWorktreeInfos(worktrees) {
@@ -14686,16 +14785,22 @@ async function mapWithConcurrency(items, limit, mapper) {
   return results;
 }
 async function readWorktreeInfo(worktree) {
-  const [healthResult, lastCommitResult] = await Promise.allSettled([
+  const [healthResult, lastCommitResult, slotResult, taskResult] = await Promise.allSettled([
     readWorktreeHealth(worktree.path),
-    worktree.branch === null ? null : readBranchLastCommitTimestamp(worktree.path, worktree.branch)
+    worktree.branch === null ? null : readBranchLastCommitTimestamp(worktree.path, worktree.branch),
+    getWorktreeSlot(worktree.path),
+    readTask(worktree.path)
   ]);
   const health = healthResult.status === "fulfilled" ? healthResult.value : null;
   const lastCommitTimestamp = lastCommitResult.status === "fulfilled" ? lastCommitResult.value : null;
+  const slot = slotResult.status === "fulfilled" ? slotResult.value : null;
+  const task = taskResult.status === "fulfilled" ? taskResult.value?.task ?? null : null;
   return {
     ...worktree,
     lastCommitTimestamp,
+    slot,
     status: health?.status ?? "unknown",
+    task,
     upstream: buildUpstreamState(worktree.branch, health)
   };
 }
@@ -14723,7 +14828,9 @@ function serializeWorktreeInfo(info) {
     branch: info.branch,
     lastCommitTimestamp: info.lastCommitTimestamp,
     path: info.path,
+    slot: info.slot,
     status: info.status,
+    task: info.task,
     upstream: info.upstream
   };
 }
@@ -14757,11 +14864,8 @@ function formatAheadBehind(ahead, behind) {
 function formatLastCommit(timestampSeconds) {
   return timestampSeconds === null ? "n/a" : formatRelativeAge(timestampSeconds);
 }
-function formatRelativeAge(timestampSeconds) {
-  const ageSeconds = Math.max(
-    0,
-    Math.floor(Date.now() / 1e3) - timestampSeconds
-  );
+function formatRelativeAge(timestampSeconds, nowSeconds = Math.floor(Date.now() / 1e3)) {
+  const ageSeconds = Math.max(0, nowSeconds - timestampSeconds);
   const units = [
     { label: "y", seconds: 365 * 24 * 60 * 60 },
     { label: "mo", seconds: 30 * 24 * 60 * 60 },
@@ -14871,6 +14975,7 @@ import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
 var execFileAsync3 = promisify4(execFile3);
 var PULL_REQUEST_QUERY_TIMEOUT_MS = 2500;
+var PULL_REQUEST_CACHE_TTL_MS = 3e4;
 function parsePullRequestRemote(remoteUrl) {
   const parsed = parseRemoteUrl(remoteUrl.trim());
   if (parsed === null) return null;
@@ -14905,10 +15010,37 @@ function parsePullRequestRemote(remoteUrl) {
 function createPullRequestQuery(dependencies = {}) {
   const runCommand2 = dependencies.runCommand ?? defaultRunCommand;
   const fetcher = dependencies.fetch ?? fetch;
+  const repositoryCache = /* @__PURE__ */ new Map();
+  const repositoryInFlight = /* @__PURE__ */ new Map();
+  const listRepositoryPullRequests = (repoRoot) => {
+    const cached = repositoryCache.get(repoRoot);
+    if (cached !== void 0 && cached.expiresAt > Date.now()) {
+      return Promise.resolve(cached.value);
+    }
+    const inFlight = repositoryInFlight.get(repoRoot);
+    if (inFlight !== void 0) return inFlight;
+    const request = listOpenPullRequestsForRepository(
+      repoRoot,
+      runCommand2,
+      fetcher
+    ).then((value) => {
+      repositoryCache.set(repoRoot, {
+        expiresAt: Date.now() + PULL_REQUEST_CACHE_TTL_MS,
+        value
+      });
+      repositoryInFlight.delete(repoRoot);
+      return value;
+    }).catch((error) => {
+      repositoryInFlight.delete(repoRoot);
+      throw error;
+    });
+    repositoryInFlight.set(repoRoot, request);
+    return request;
+  };
   return {
     findOpenPullRequest: (repoRoot, number) => findOpenPullRequest(repoRoot, number, runCommand2, fetcher),
     listOpenPullRequests: (repoRoot, sourceBranch) => listOpenPullRequests(repoRoot, sourceBranch, runCommand2, fetcher),
-    listOpenPullRequestsForRepository: (repoRoot) => listOpenPullRequestsForRepository(repoRoot, runCommand2, fetcher)
+    listOpenPullRequestsForRepository: listRepositoryPullRequests
   };
 }
 async function listOpenPullRequests(repoRoot, sourceBranch, runCommand2, fetcher) {
@@ -15039,7 +15171,7 @@ function providerCliCommand(remote, query) {
             "view",
             String(query.number),
             "--json",
-            "number,url,headRefName,state",
+            "number,url,headRefName,title,state",
             "--repo",
             coordinate
           ],
@@ -15054,7 +15186,7 @@ function providerCliCommand(remote, query) {
           "open",
           ...query.kind === "branch" ? ["--head", sourceBranch] : [],
           "--json",
-          "number,url,headRefName,state",
+          "number,url,headRefName,title,state",
           "--limit",
           "100",
           "--repo",
@@ -15155,6 +15287,7 @@ function normalizePullRequest(value, query) {
   const url = stringValue(
     value.html_url ?? value.web_url ?? value.url ?? (isRecord(value.links) && isRecord(value.links.html) ? value.links.html.href : void 0)
   );
+  const title = stringValue(value.title);
   const state = stringValue(value.state)?.toLowerCase();
   if (number === null || url === null) return null;
   if (query.kind !== "number" && sourceBranch === null) return null;
@@ -15163,6 +15296,7 @@ function normalizePullRequest(value, query) {
   return {
     number,
     sourceBranch: sourceBranch ?? "",
+    ...title === null ? {} : { title },
     url
   };
 }
@@ -15226,8 +15360,61 @@ function numberValue(value) {
   return null;
 }
 
+// src/terminal-text.ts
+function sanitizeTerminalText(value) {
+  return Array.from(value, (character) => {
+    const codePoint = character.codePointAt(0) ?? 0;
+    return codePoint <= 31 || codePoint >= 127 && codePoint <= 159 ? " " : character;
+  }).join("");
+}
+function middleEllipsize(value, maxLength) {
+  if (terminalWidth(value) <= maxLength) return value;
+  if (maxLength <= 1) return "\u2026";
+  const keep = maxLength - 1;
+  const start = takeTerminalColumns(value, Math.ceil(keep / 2), "start");
+  const end = takeTerminalColumns(value, Math.floor(keep / 2), "end");
+  return `${start}\u2026${end}`;
+}
+function startEllipsize(value, maxLength) {
+  if (terminalWidth(value) <= maxLength) return value;
+  if (maxLength <= 1) return "\u2026";
+  return `\u2026${takeTerminalColumns(value, maxLength - 1, "end")}`;
+}
+function terminalWidth(value) {
+  let width = 0;
+  for (const character of Array.from(value)) {
+    width += characterTerminalWidth(character);
+  }
+  return width;
+}
+function takeTerminalColumns(value, maxWidth, direction) {
+  const characters = direction === "start" ? Array.from(value) : Array.from(value).reverse();
+  const kept = [];
+  let width = 0;
+  for (const character of characters) {
+    const characterWidth = characterTerminalWidth(character);
+    if (width + characterWidth > maxWidth) break;
+    kept.push(character);
+    width += characterWidth;
+  }
+  return direction === "start" ? kept.join("") : kept.reverse().join("");
+}
+function characterTerminalWidth(character) {
+  const codePoint = character.codePointAt(0);
+  if (codePoint === void 0) return 0;
+  if (isZeroWidthCodePoint(codePoint) || new RegExp("\\p{Mark}", "u").test(character)) return 0;
+  return isWideCodePoint(codePoint) ? 2 : 1;
+}
+function isZeroWidthCodePoint(codePoint) {
+  return codePoint === 0 || codePoint === 8205 || codePoint >= 65024 && codePoint <= 65039;
+}
+function isWideCodePoint(codePoint) {
+  return codePoint >= 4352 && codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 42191 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127744 && codePoint <= 129791 || codePoint >= 131072 && codePoint <= 262141;
+}
+
 // src/worktree-picker.ts
 var MAX_PULL_REQUEST_REPOSITORY_QUERY_CONCURRENCY = 4;
+var MAX_TASK_READ_CONCURRENCY = 8;
 async function buildWorktreePromptEntries(sources, dependencies = {}) {
   const metadataMode = dependencies.metadata ?? "full";
   const includeMetadata = metadataMode === "full";
@@ -15237,10 +15424,10 @@ async function buildWorktreePromptEntries(sources, dependencies = {}) {
   const repositoryPullRequests = queryRepositoryPullRequests === void 0 ? Promise.resolve(null) : readRepositoryPullRequests(sources, queryRepositoryPullRequests);
   const [history, infos, pullRequestsByRepository] = await Promise.all([
     loadHistory(),
-    includeMetadata ? readWorktreeInfos(sources.map((source) => source.worktree)) : Promise.resolve(
-      sources.map(
-        (source) => createUnhydratedWorktreeInfo(source.worktree)
-      )
+    includeMetadata ? readWorktreeInfos(sources.map((source) => source.worktree)) : mapWithConcurrency2(
+      sources,
+      MAX_TASK_READ_CONCURRENCY,
+      (source) => createUnhydratedWorktreeInfo(source.worktree)
     ),
     repositoryPullRequests
   ]);
@@ -15267,11 +15454,18 @@ async function buildWorktreePromptEntries(sources, dependencies = {}) {
     ({ lastActivityTimestamp: _lastActivityTimestamp, ...entry }) => entry
   );
 }
-function createUnhydratedWorktreeInfo(worktree) {
+async function createUnhydratedWorktreeInfo(worktree) {
+  let task = null;
+  try {
+    task = (await readTask(worktree.path))?.task ?? null;
+  } catch {
+  }
   return {
     ...worktree,
     lastCommitTimestamp: null,
+    slot: null,
     status: "unknown",
+    task,
     upstream: { kind: "unknown" }
   };
 }
@@ -15377,18 +15571,22 @@ function buildSearchableWorktreeEntry(worktree) {
   const metadata = worktree.metadata ?? null;
   const branch = worktree.branch ?? "(detached)";
   return {
-    detail: [worktree.repoName, branch, metadata, worktree.path].filter((part) => part !== null && part.length > 0).join(" \xB7 "),
+    detail: [
+      worktree.repoName,
+      branch,
+      metadata,
+      worktree.task == null ? null : sanitizeTerminalText(worktree.task),
+      worktree.path
+    ].filter((part) => part !== null && part.length > 0).join(" \xB7 "),
     label: worktree.label,
     searchText: buildPromptSearchText(worktree),
     value: worktree.path,
     worktree: {
-      branch: formatWorktreeBranchLabel(
-        worktree.branch,
-        worktree.pullRequestNumbers
-      ),
+      branch: formatWorktreeBranchLabel(worktree.branch, worktree.pullRequests),
       metadata,
       path: worktree.path,
-      repoName: worktree.repoName
+      repoName: worktree.repoName,
+      task: worktree.task == null ? null : sanitizeTerminalText(worktree.task)
     }
   };
 }
@@ -15706,6 +15904,7 @@ var SearchablePrompt = class {
           ellipsize: middleEllipsize,
           max: 18,
           min: 6,
+          removablePriority: entry.worktree.task === null ? void 0 : 1,
           value: entry.worktree.repoName
         },
         {
@@ -15719,13 +15918,23 @@ var SearchablePrompt = class {
             ellipsize: middleEllipsize,
             max: 30,
             min: 10,
+            removablePriority: entry.worktree.task === null ? void 0 : 0,
             value: entry.worktree.metadata
           }
         ],
+        ...entry.worktree.task === null ? [] : [
+          {
+            ellipsize: middleEllipsize,
+            max: 36,
+            min: 10,
+            value: entry.worktree.task
+          }
+        ],
         {
           ellipsize: startEllipsize,
           max: 36,
           min: 12,
+          removablePriority: entry.worktree.task === null ? void 0 : 2,
           value: entry.worktree.path
         }
       ],
@@ -15940,12 +16149,27 @@ function windowPromptEntries(entries, cursor, maxItems) {
   }
   return window;
 }
+function findPromptPieceToRemove(pieces, fallbackIndex) {
+  let candidate = fallbackIndex;
+  let priority = Infinity;
+  for (let index = 0; index < pieces.length; index += 1) {
+    const piecePriority = pieces[index].removablePriority;
+    if (piecePriority !== void 0 && piecePriority < priority) {
+      candidate = index;
+      priority = piecePriority;
+    }
+  }
+  return candidate;
+}
 function fitPromptPieces(pieces, width) {
   const separator = " \xB7 ";
   let visiblePieces = pieces.filter((piece) => piece.value.length > 0);
   let available = width - terminalWidth(separator) * Math.max(0, visiblePieces.length - 1);
   while (visiblePieces.length > 1 && available < minimumPieceLength(visiblePieces)) {
-    const removableIndex = visiblePieces.length === 4 ? 2 : visiblePieces.length - 2;
+    const removableIndex = findPromptPieceToRemove(
+      visiblePieces,
+      visiblePieces.length === 4 ? 2 : visiblePieces.length - 2
+    );
     visiblePieces = visiblePieces.filter(
       (_3, index) => index !== removableIndex
     );
@@ -16015,9 +16239,13 @@ function buildPromptSearchText(worktree) {
     worktree.branch ?? "detached",
     worktree.path,
     worktree.label,
+    worktree.task ?? "",
     `${worktree.repoName}/${worktree.branch ?? "detached"}`,
-    ...(worktree.pullRequestNumbers ?? []).map((number) => `#${number}`),
-    ...worktree.pullRequestUrls ?? []
+    ...(worktree.pullRequests ?? []).flatMap((pullRequest) => [
+      `#${pullRequest.number}`,
+      pullRequest.title ?? "",
+      pullRequest.url
+    ])
   ].join(" ").toLowerCase();
 }
 function buildWorktreePromptEntry(source, info, pullRequests, lastUsedTimestamp, now) {
@@ -16026,7 +16254,7 @@ function buildWorktreePromptEntry(source, info, pullRequests, lastUsedTimestamp,
   const lastActivityType = lastUsedTimestamp !== null ? "used" : lastWorkedTimestamp !== null ? "worked" : null;
   const branch = formatWorktreeBranchLabel(
     source.worktree.branch,
-    pullRequests.map((pullRequest) => pullRequest.number)
+    pullRequests
   );
   const badges = buildStatusBadges(info);
   const recency = formatPromptRecency(
@@ -16044,6 +16272,7 @@ function buildWorktreePromptEntry(source, info, pullRequests, lastUsedTimestamp,
     middleEllipsize(source.repoName, 22),
     middleEllipsize(branch, 34),
     metadata,
+    info.task === null ? null : middleEllipsize(sanitizeTerminalText(info.task), 36),
     path9
   ].filter((part) => part !== null && part.length > 0).join(" \xB7 ");
   return {
@@ -16052,9 +16281,9 @@ function buildWorktreePromptEntry(source, info, pullRequests, lastUsedTimestamp,
     label,
     lastActivityTimestamp,
     metadata,
-    pullRequestNumbers: pullRequests.map((pullRequest) => pullRequest.number),
-    pullRequestUrls: pullRequests.map((pullRequest) => pullRequest.url),
-    repoName: source.repoName
+    pullRequests,
+    repoName: source.repoName,
+    task: info.task
   };
 }
 async function readSourcePullRequests(source, queryPullRequests, pullRequestsByRepository) {
@@ -16121,10 +16350,13 @@ async function mapWithConcurrency2(items, limit, mapper) {
 function sortSourcePullRequests(pullRequests) {
   return [...pullRequests ?? []].sort((a, b3) => a.number - b3.number);
 }
-function formatWorktreeBranchLabel(branch, pullRequestNumbers = []) {
+function formatWorktreeBranchLabel(branch, pullRequests = []) {
   const branchLabel = branch ?? "(detached)";
-  if (pullRequestNumbers.length === 0) return branchLabel;
-  return `${branchLabel} (${pullRequestNumbers.map((number) => `#${number}`).join(", ")})`;
+  if (pullRequests.length === 0) return branchLabel;
+  return `${branchLabel} (${pullRequests.map((pullRequest) => {
+    const title = pullRequest.title ? ` ${middleEllipsize(sanitizeTerminalText(pullRequest.title), 48)}` : "";
+    return `#${pullRequest.number}${title}`;
+  }).join(", ")})`;
 }
 function buildStatusBadges(info) {
   const badges = [];
@@ -16220,60 +16452,6 @@ function scoreWorktreeMatch(entry, query) {
   }
   return buildSearchText(entry.repoName, entry).includes(query) ? 1 : null;
 }
-function middleEllipsize(value, maxLength) {
-  if (terminalWidth(value) <= maxLength) {
-    return value;
-  }
-  if (maxLength <= 1) {
-    return "\u2026";
-  }
-  const keep = maxLength - 1;
-  const start = takeTerminalColumns(value, Math.ceil(keep / 2), "start");
-  const end = takeTerminalColumns(value, Math.floor(keep / 2), "end");
-  return `${start}\u2026${end}`;
-}
-function startEllipsize(value, maxLength) {
-  if (terminalWidth(value) <= maxLength) {
-    return value;
-  }
-  if (maxLength <= 1) {
-    return "\u2026";
-  }
-  return `\u2026${takeTerminalColumns(value, maxLength - 1, "end")}`;
-}
-function takeTerminalColumns(value, maxWidth, direction) {
-  const characters = direction === "start" ? Array.from(value) : Array.from(value).reverse();
-  const kept = [];
-  let width = 0;
-  for (const character of characters) {
-    const characterWidth = terminalWidth(character);
-    if (width + characterWidth > maxWidth) break;
-    kept.push(character);
-    width += characterWidth;
-  }
-  return direction === "start" ? kept.join("") : kept.reverse().join("");
-}
-function terminalWidth(value) {
-  let width = 0;
-  for (const character of Array.from(value)) {
-    width += characterTerminalWidth(character);
-  }
-  return width;
-}
-function characterTerminalWidth(character) {
-  const codePoint = character.codePointAt(0);
-  if (codePoint === void 0) return 0;
-  if (isZeroWidthCodePoint(codePoint) || new RegExp("\\p{Mark}", "u").test(character)) {
-    return 0;
-  }
-  return isWideCodePoint(codePoint) ? 2 : 1;
-}
-function isZeroWidthCodePoint(codePoint) {
-  return codePoint === 0 || codePoint === 8205 || codePoint >= 65024 && codePoint <= 65039;
-}
-function isWideCodePoint(codePoint) {
-  return codePoint >= 4352 && codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 42191 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127744 && codePoint <= 129791 || codePoint >= 131072 && codePoint <= 262141;
-}
 
 // src/worktree-prompts.ts
 async function defaultConfirmForceRemoveWorktree(worktreePath) {
@@ -16486,6 +16664,9 @@ function createCleanCommand(dependencies = {}) {
       }
     }
     await finalizeUndoOperation(journal, removedWorktrees);
+    await Promise.all(
+      removedWorktrees.map((worktree) => releaseWorktreeSlot(worktree.path))
+    );
     if (options.json) {
       const removed = removedWorktrees.map((worktree) => {
         const info = selectedInfoByPath.get(worktree.path);
@@ -16700,6 +16881,7 @@ var TOP_LEVEL_COMMANDS = [
   { name: "jump", description: "alias of go" },
   { name: "root", description: "print the main repository root path" },
   { name: "status", description: "summarize repository and worktree health" },
+  { name: "task", description: "show or update the current worktree task" },
   { name: "sync", description: "fetch and update one or all worktrees" },
   {
     name: "sync-files",
@@ -16816,7 +16998,7 @@ _gji_completion() {
   cur="\${COMP_WORDS[COMP_CWORD]:-}"
 
   if [ "$COMP_CWORD" -eq 1 ]; then
-    COMPREPLY=( $(compgen -W "${topLevelCommands}" -- "$cur") )
+		COMPREPLY=( $(compgen -W "${topLevelCommands} --json --help" -- "$cur") )
     return 0
   fi
 
@@ -16824,7 +17006,7 @@ _gji_completion() {
 
   case "$command_name" in
     new)
-      COMPREPLY=( $(compgen -W "--detached --from-current --no-fetch --take --copy --force --open --editor --dry-run --json --help" -- "$cur") )
+				COMPREPLY=( $(compgen -W "--detached --from-current --no-fetch --take --copy --task --force --open --editor --dry-run --json --help" -- "$cur") )
       ;;
     done)
       COMPREPLY=( $(compgen -W "--force --keep-branch --json --help" -- "$cur") )
@@ -17075,6 +17257,7 @@ complete -c gji -n '__fish_seen_subcommand_from new' -l detached -d 'create a de
 complete -c gji -n '__fish_seen_subcommand_from new' -l from-current -d 'base the new branch on the current worktree instead of the main worktree'
 complete -c gji -n '__fish_seen_subcommand_from new' -l take -d 'move current uncommitted changes into the new worktree'
 complete -c gji -n '__fish_seen_subcommand_from new' -l copy -d 'copy current uncommitted changes instead of moving them (requires --take)'
+complete -c gji -n '__fish_seen_subcommand_from new' -l task -r -d 'record the purpose of the new worktree'
 complete -c gji -n '__fish_seen_subcommand_from new' -l force -d 'remove and recreate the worktree if the target path already exists'
 complete -c gji -n '__fish_seen_subcommand_from new' -l open -d 'open the new worktree in an editor after creation'
 complete -c gji -n '__fish_seen_subcommand_from new' -l editor -r -d 'editor CLI to use with --open (code, cursor, zed, \u2026)'
@@ -17112,11 +17295,14 @@ complete -c gji -n '__fish_seen_subcommand_from open' -a '(__gji_worktree_branch
 complete -c gji -n '__fish_seen_subcommand_from go jump' -l print -d 'print the resolved worktree path explicitly'
 complete -c gji -n '__fish_seen_subcommand_from go jump' -l root -d 'navigate to the main repository root'
 complete -c gji -n '__fish_seen_subcommand_from go jump' -l json -d 'emit JSON for an existing worktree destination'
+complete -c gji -n '__fish_seen_subcommand_from go jump' -l quiet -d 'suppress the context card'
 complete -c gji -n '__fish_seen_subcommand_from go jump' -a '(__gji_worktree_branches)' -d 'worktree branch'
 
 complete -c gji -n '__fish_seen_subcommand_from root' -l print -d 'print the resolved repository root path explicitly'
 
 complete -c gji -n '__fish_seen_subcommand_from status' -l json -d 'print repository and worktree health as JSON'
+complete -c gji -n '__fish_seen_subcommand_from task' -l clear -d 'clear the current worktree task'
+complete -c gji -n '__fish_seen_subcommand_from task' -l json -d 'emit task metadata as JSON'
 
 complete -c gji -n '__fish_seen_subcommand_from sync' -l all -d 'sync every worktree in the repository'
 complete -c gji -n '__fish_seen_subcommand_from sync' -l json -d 'emit JSON on success or error instead of human-readable output'
@@ -17142,6 +17328,8 @@ complete -c gji -n '__fish_seen_subcommand_from remove rm' -a '(__gji_worktree_b
 
 ${hookLines}
 
+complete -c gji -n '__fish_use_subcommand' -l json -d 'emit the repository hub as JSON'
+
 complete -c gji -n '__fish_seen_subcommand_from warp' -l print -d 'print the resolved worktree path without changing directory'
 complete -c gji -n '__fish_seen_subcommand_from warp' -l json -d 'emit JSON on success or error instead of human-readable output'
 
@@ -17222,6 +17410,7 @@ local -a command_entries worktree_branches
 
 command_entries=(
   ${commandLines}
+  '--json:emit the repository hub as JSON'
 )
 
 if (( CURRENT == 2 )); then
@@ -17231,7 +17420,7 @@ fi
 
 case "\${words[2]}" in
   new)
-    _arguments '--detached[create a detached worktree without a branch]' '--from-current[base the new branch on the current worktree instead of the main worktree]' '--no-fetch[skip refreshing the remote default branch before creating the new branch]' '--take[move current uncommitted changes into the new worktree]' '--copy[copy current uncommitted changes instead of moving them (requires --take)]' '--force[remove and recreate the worktree if the target path already exists]' '--open[open the new worktree in an editor after creation]' '--editor[editor CLI to use with --open (code, cursor, zed, \u2026)]:editor:' '--dry-run[show what would be created without executing any git commands or writing files]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
+    _arguments '--detached[create a detached worktree without a branch]' '--from-current[base the new branch on the current worktree instead of the main worktree]' '--no-fetch[skip refreshing the remote default branch before creating the new branch]' '--take[move current uncommitted changes into the new worktree]' '--copy[copy current uncommitted changes instead of moving them (requires --take)]' '--task[record the purpose of the new worktree]:description:' '--force[remove and recreate the worktree if the target path already exists]' '--open[open the new worktree in an editor after creation]' '--editor[editor CLI to use with --open (code, cursor, zed, \u2026)]:editor:' '--dry-run[show what would be created without executing any git commands or writing files]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
     ;;
   done)
     _arguments '--force[remove dirty or unmerged worktrees without prompting]' '--keep-branch[remove the worktree but preserve its branch]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
@@ -17400,9 +17589,9 @@ function writeJson(stdout2, value) {
 // src/doctor.ts
 import { execFile as execFile4 } from "node:child_process";
 import { constants as constants3 } from "node:fs";
-import { access as access6, readFile as readFile5 } from "node:fs/promises";
-import { homedir as homedir6 } from "node:os";
-import { basename as basename4, dirname as dirname6, join as join7 } from "node:path";
+import { access as access6, readFile as readFile7 } from "node:fs/promises";
+import { homedir as homedir7 } from "node:os";
+import { basename as basename4, dirname as dirname7, join as join9 } from "node:path";
 import { promisify as promisify5 } from "node:util";
 
 // src/editor.ts
@@ -17436,9 +17625,9 @@ var EDITORS = [
 ];
 async function defaultSpawnEditor(cli, args) {
   const child = spawn3(cli, args, { detached: true, stdio: "ignore" });
-  await new Promise((resolve12, reject) => {
+  await new Promise((resolve13, reject) => {
     child.once("error", reject);
-    child.once("spawn", resolve12);
+    child.once("spawn", resolve13);
   });
   child.unref();
 }
@@ -17448,29 +17637,29 @@ import { randomUUID } from "node:crypto";
 import { constants } from "node:fs";
 import {
   access as access4,
-  mkdir as mkdir4,
-  readFile as readFile4,
+  mkdir as mkdir5,
+  readFile as readFile6,
   realpath,
   rename as rename2,
   rm as rm2,
-  writeFile as writeFile5
+  writeFile as writeFile7
 } from "node:fs/promises";
-import { homedir as homedir5 } from "node:os";
-import { basename as basename3, dirname as dirname5, join as join5, resolve as resolve5 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+import { basename as basename3, dirname as dirname6, join as join7, resolve as resolve6 } from "node:path";
 var REGISTRY_FILE_NAME = "repos.json";
 var MAX_REGISTRY_ENTRIES = 100;
 var registryLocks = /* @__PURE__ */ new Map();
-function REGISTRY_FILE_PATH(home = homedir5()) {
+function REGISTRY_FILE_PATH(home = homedir6()) {
   const configDir = process.env.GJI_CONFIG_DIR;
   if (configDir) {
-    return join5(resolve5(configDir), REGISTRY_FILE_NAME);
+    return join7(resolve6(configDir), REGISTRY_FILE_NAME);
   }
-  return join5(home, GLOBAL_CONFIG_DIRECTORY, REGISTRY_FILE_NAME);
+  return join7(home, GLOBAL_CONFIG_DIRECTORY, REGISTRY_FILE_NAME);
 }
-async function loadRegistry(home = homedir5()) {
+async function loadRegistry(home = homedir6()) {
   const path9 = REGISTRY_FILE_PATH(home);
   try {
-    const raw = await readFile4(path9, "utf8");
+    const raw = await readFile6(path9, "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) return [];
     return parsed.filter(isRegistryEntry);
@@ -17482,10 +17671,10 @@ async function canonicalizeRepoPath(repoPath) {
   try {
     return await realpath(repoPath);
   } catch {
-    return resolve5(repoPath);
+    return resolve6(repoPath);
   }
 }
-async function registerRepo(repoPath, home = homedir5()) {
+async function registerRepo(repoPath, home = homedir6()) {
   const registryPath = REGISTRY_FILE_PATH(home);
   await withRegistryLock(registryPath, async () => {
     const existing = await normalizeRegistryForWrite(await loadRegistry(home));
@@ -17501,7 +17690,7 @@ async function registerRepo(repoPath, home = homedir5()) {
     await writeRegistry(next, registryPath);
   });
 }
-async function removeMissingRegistryEntries(paths, home = homedir5()) {
+async function removeMissingRegistryEntries(paths, home = homedir6()) {
   if (paths.size === 0) return { removedPaths: [], skippedPaths: [] };
   const registryPath = REGISTRY_FILE_PATH(home);
   return withRegistryLock(registryPath, async () => {
@@ -17527,8 +17716,8 @@ async function removeMissingRegistryEntries(paths, home = homedir5()) {
 async function withRegistryLock(registryPath, operation) {
   const previous = registryLocks.get(registryPath);
   let release;
-  const current = new Promise((resolve12) => {
-    release = resolve12;
+  const current = new Promise((resolve13) => {
+    release = resolve13;
   });
   registryLocks.set(registryPath, current);
   if (previous) await previous;
@@ -17555,10 +17744,10 @@ function isMissingPathError(error) {
   return code === "ENOENT" || code === "ENOTDIR";
 }
 async function writeRegistry(entries, registryPath) {
-  await mkdir4(dirname5(registryPath), { recursive: true });
+  await mkdir5(dirname6(registryPath), { recursive: true });
   const temporaryPath = `${registryPath}.tmp-${process.pid}-${randomUUID()}`;
   try {
-    await writeFile5(
+    await writeFile7(
       temporaryPath,
       `${JSON.stringify(entries, null, 2)}
 `,
@@ -17594,13 +17783,13 @@ function isRegistryEntry(value) {
 // src/shell-setup.ts
 import { constants as constants2 } from "node:fs";
 import { access as access5 } from "node:fs/promises";
-import { delimiter, join as join6 } from "node:path";
+import { delimiter, join as join8 } from "node:path";
 var SHELL_INTEGRATION_START_MARKER = "# >>> gji init >>>";
 var SHELL_INTEGRATION_END_MARKER = "# <<< gji init <<<";
 var ONBOARDING_SHELL_INTEGRATION_START_MARKER = "# >>> gji shell integration >>>";
 var ONBOARDING_SHELL_INTEGRATION_END_MARKER = "# <<< gji shell integration <<<";
 async function executableExists(command) {
-  const candidates = command.includes("/") ? [command] : (process.env.PATH ?? "").split(delimiter).filter(Boolean).map((directory) => join6(directory, command));
+  const candidates = command.includes("/") ? [command] : (process.env.PATH ?? "").split(delimiter).filter(Boolean).map((directory) => join8(directory, command));
   for (const path9 of candidates) {
     try {
       await access5(path9, constants2.X_OK);
@@ -17613,17 +17802,17 @@ async function executableExists(command) {
 function resolveShellConfigPath(shell, home) {
   switch (shell) {
     case "bash":
-      return join6(home, ".bashrc");
+      return join8(home, ".bashrc");
     case "fish":
-      return join6(home, ".config", "fish", "config.fish");
+      return join8(home, ".config", "fish", "config.fish");
     case "zsh":
-      return join6(home, ".zshrc");
+      return join8(home, ".zshrc");
   }
 }
 function resolveCompletionPath(shell, home) {
   switch (shell) {
     case "bash":
-      return join6(
+      return join8(
         home,
         ".local",
         "share",
@@ -17632,9 +17821,9 @@ function resolveCompletionPath(shell, home) {
         "gji"
       );
     case "fish":
-      return join6(home, ".config", "fish", "completions", "gji.fish");
+      return join8(home, ".config", "fish", "completions", "gji.fish");
     case "zsh":
-      return join6(home, ".zsh", "completions", "_gji");
+      return join8(home, ".zsh", "completions", "_gji");
   }
 }
 function hasShellIntegration(config, shell) {
@@ -17665,7 +17854,7 @@ async function runDoctorCommand(options) {
     }
     return 1;
   }
-  const home = options.home ?? homedir6();
+  const home = options.home ?? homedir7();
   const shell = resolveSupportedShell(
     void 0,
     options.shell ?? process.env.SHELL
@@ -17711,7 +17900,7 @@ async function collectDoctorInspection(cwd, home, shell) {
     KNOWN_GLOBAL_CONFIG_KEYS
   );
   const localConfig = repository ? await inspectConfig(
-    join7(repository.repoRoot, CONFIG_FILE_NAME),
+    join9(repository.repoRoot, CONFIG_FILE_NAME),
     "local",
     KNOWN_CONFIG_KEYS
   ) : null;
@@ -17734,11 +17923,30 @@ async function collectDoctorInspection(cwd, home, shell) {
       ),
       await checkWorktreeBase(repository, effectiveConfig, home),
       registry.check,
-      await checkEditor(effectiveConfig)
+      await checkEditor(effectiveConfig),
+      await checkOrphanSlots(home)
     ],
     missingRegistryPaths: registry.missingPaths
   };
 }
+async function checkOrphanSlots(home) {
+  const slots = await loadSlots(home);
+  const missing = (await Promise.all(
+    Object.keys(slots).map(async (path9) => {
+      try {
+        await access6(path9);
+        return false;
+      } catch {
+        return true;
+      }
+    })
+  )).filter(Boolean).length;
+  return {
+    id: "slots",
+    message: missing === 0 ? "worktree slots healthy" : `${missing} orphaned worktree slot${missing === 1 ? "" : "s"}`,
+    status: "ok"
+  };
+}
 function buildDoctorFixes(missingRegistryPaths) {
   if (missingRegistryPaths.length === 0) return [];
   const count = missingRegistryPaths.length;
@@ -17801,7 +18009,7 @@ async function detectRepositoryOrSkip(cwd) {
 }
 async function inspectConfig(path9, label, knownKeys) {
   try {
-    const contents = await readFile5(path9, "utf8");
+    const contents = await readFile7(path9, "utf8");
     const value = JSON.parse(contents);
     if (!isConfigObject(value)) {
       return {
@@ -17871,7 +18079,7 @@ function resolvePerRepoConfig(repos, repoRoot, home) {
 }
 function expandTilde2(path9, home) {
   if (path9 === "~") return home;
-  if (path9.startsWith("~/")) return join7(home, path9.slice(2));
+  if (path9.startsWith("~/")) return join9(home, path9.slice(2));
   return path9;
 }
 async function checkGitVersion() {
@@ -17922,7 +18130,7 @@ async function checkShellIntegration(shell, home) {
   }
   const rcPath = resolveShellConfigPath(shell, home);
   try {
-    const contents = await readFile5(rcPath, "utf8");
+    const contents = await readFile7(rcPath, "utf8");
     if (hasShellIntegration(contents, shell)) {
       return okCheck(
         "shell-integration",
@@ -17998,7 +18206,7 @@ function resolveWorktreeBase(repoRoot, config, home) {
   if (typeof configuredPath === "string" && (configuredPath.startsWith("/") || configuredPath.startsWith("~"))) {
     return expandTilde2(configuredPath, home);
   }
-  return join7(dirname6(repoRoot), "worktrees", basename4(repoRoot));
+  return join9(dirname7(repoRoot), "worktrees", basename4(repoRoot));
 }
 async function findNearestExistingPath(path9) {
   let candidate = path9;
@@ -18007,7 +18215,7 @@ async function findNearestExistingPath(path9) {
       await access6(candidate, constants3.F_OK);
       return candidate;
     } catch {
-      const parent = dirname6(candidate);
+      const parent = dirname7(candidate);
       if (parent === candidate) return null;
       candidate = parent;
     }
@@ -18308,6 +18516,7 @@ async function runDoneCommand(options) {
     }
   }
   await finalizeUndoOperation(journal, [target]);
+  await releaseWorktreeSlot(target.path);
   await runGit(repository.repoRoot, ["worktree", "prune"]).catch(
     () => void 0
   );
@@ -18397,10 +18606,34 @@ function toMessage3(error) {
 // src/go.ts
 import { basename as basename9 } from "node:path";
 
+// src/context-card.ts
+async function renderContextCard(worktreePath) {
+  const worktree = (await listWorktrees(worktreePath)).find(
+    (entry) => entry.path === worktreePath
+  );
+  if (!worktree) return null;
+  const info = await readWorktreeInfo(worktree);
+  const task = await readTask(worktreePath);
+  if (!task) return null;
+  const rows = [`\u250C ${info.branch ?? "(detached)"}`];
+  rows.push(`\u2502 task   ${task.task}`);
+  rows.push(`\u2502 state  ${formatState(info)}`);
+  if (info.lastCommitTimestamp !== null)
+    rows.push(`\u2502 last   ${formatLastCommit2(info)}`);
+  rows.push("\u2514");
+  return rows.join("\n");
+}
+function formatState(info) {
+  return `${info.status}${info.upstream.kind === "tracked" ? ` \xB7 \u2191${info.upstream.ahead} \u2193${info.upstream.behind}` : ""}`;
+}
+function formatLastCommit2(info) {
+  return new Date(info.lastCommitTimestamp).toISOString();
+}
+
 // src/pr.ts
 import { execFile as execFile7 } from "node:child_process";
-import { mkdir as mkdir8 } from "node:fs/promises";
-import { dirname as dirname10 } from "node:path";
+import { mkdir as mkdir9 } from "node:fs/promises";
+import { dirname as dirname11 } from "node:path";
 import { promisify as promisify8 } from "node:util";
 
 // src/format-bytes.ts
@@ -18449,27 +18682,27 @@ function formatDuration(ms) {
 
 // src/dependency-bootstrap.ts
 import { execFile as execFile6 } from "node:child_process";
-import { lstat as lstat4, readFile as readFile8, realpath as realpath3, rm as rm5 } from "node:fs/promises";
-import { join as join11, relative as relative2, resolve as resolve8, sep as sep2 } from "node:path";
+import { lstat as lstat4, readFile as readFile10, realpath as realpath3, rm as rm5 } from "node:fs/promises";
+import { join as join13, relative as relative2, resolve as resolve9, sep as sep2 } from "node:path";
 import { promisify as promisify7 } from "node:util";
 
 // src/clone-failure-store.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
-  mkdir as mkdir5,
+  mkdir as mkdir6,
   mkdtemp,
   readdir,
-  readFile as readFile6,
+  readFile as readFile8,
   rename as rename3,
   rm as rm3,
   rmdir,
   stat as stat2,
-  unlink as unlink2,
+  unlink as unlink3,
   utimes,
-  writeFile as writeFile6
+  writeFile as writeFile8
 } from "node:fs/promises";
-import { homedir as homedir7 } from "node:os";
-import { dirname as dirname7, join as join8, resolve as resolve6 } from "node:path";
+import { homedir as homedir8 } from "node:os";
+import { dirname as dirname8, join as join10, resolve as resolve7 } from "node:path";
 var STATE_FILE_NAME = "state.json";
 var STATE_LOCK_SUFFIX = ".lock";
 var CLONE_FAILURE_TTL_MS = 24 * 60 * 60 * 1e3;
@@ -18536,7 +18769,7 @@ var FileCloneFailureStore = class {
   }
   async readState() {
     try {
-      const raw = await readFile6(this.stateFilePath(), "utf8");
+      const raw = await readFile8(this.stateFilePath(), "utf8");
       const parsed = JSON.parse(raw);
       if (!isPlainObject2(parsed)) return {};
       return isPlainObject2(parsed.syncDirs) ? parsed : { ...parsed, syncDirs: {} };
@@ -18547,14 +18780,14 @@ var FileCloneFailureStore = class {
   async writeState(state) {
     try {
       const path9 = this.stateFilePath();
-      const directory = dirname7(path9);
-      await mkdir5(directory, { recursive: true });
+      const directory = dirname8(path9);
+      await mkdir6(directory, { recursive: true });
       const temporaryDirectory = await mkdtemp(
-        join8(directory, `.gji-state-${randomUUID2()}-`)
+        join10(directory, `.gji-state-${randomUUID2()}-`)
       );
-      const temporaryPath = join8(temporaryDirectory, STATE_FILE_NAME);
+      const temporaryPath = join10(temporaryDirectory, STATE_FILE_NAME);
       try {
-        await writeFile6(
+        await writeFile8(
           temporaryPath,
           `${JSON.stringify(state, null, 2)}
 `,
@@ -18567,18 +18800,18 @@ var FileCloneFailureStore = class {
     } catch {
     }
   }
-  stateFilePath(home = homedir7()) {
+  stateFilePath(home = homedir8()) {
     const configuredDirectory = process.env.GJI_CONFIG_DIR;
-    const directory = configuredDirectory ? resolve6(configuredDirectory) : join8(home, GLOBAL_CONFIG_DIRECTORY);
-    return join8(directory, STATE_FILE_NAME);
+    const directory = configuredDirectory ? resolve7(configuredDirectory) : join10(home, GLOBAL_CONFIG_DIRECTORY);
+    return join10(directory, STATE_FILE_NAME);
   }
 };
 async function acquireStateLock(lockPath) {
   const lockToken = randomUUID2();
-  await mkdir5(dirname7(lockPath), { recursive: true }).catch(() => void 0);
+  await mkdir6(dirname8(lockPath), { recursive: true }).catch(() => void 0);
   for (let attempt = 0; attempt < 200; attempt += 1) {
     try {
-      await mkdir5(lockPath);
+      await mkdir6(lockPath);
     } catch (error) {
       if (!isErrorCode(error, "EEXIST")) return void 0;
       try {
@@ -18598,12 +18831,12 @@ async function acquireStateLock(lockPath) {
       } catch (lockError) {
         if (!isErrorCode(lockError, "ENOENT")) return void 0;
       }
-      await new Promise((resolve12) => setTimeout(resolve12, 25));
+      await new Promise((resolve13) => setTimeout(resolve13, 25));
       continue;
     }
     try {
-      await writeFile6(
-        join8(lockPath, ownerFileName(lockToken)),
+      await writeFile8(
+        join10(lockPath, ownerFileName(lockToken)),
         `${lockToken}
 `,
         {
@@ -18625,7 +18858,7 @@ async function lockFreshnessPath(lockPath) {
     const owner = (await readdir(lockPath)).find(
       (entry) => entry.startsWith("owner-")
     );
-    return owner ? join8(lockPath, owner) : lockPath;
+    return owner ? join10(lockPath, owner) : lockPath;
   } catch (error) {
     if (isErrorCode(error, "ENOENT")) throw error;
     return lockPath;
@@ -18640,8 +18873,8 @@ function startStateLockHeartbeat(lockPath, lockToken) {
 }
 async function refreshStateLock(lockPath, lockToken) {
   try {
-    const ownerPath = join8(lockPath, ownerFileName(lockToken));
-    await readFile6(ownerPath, "utf8");
+    const ownerPath = join10(lockPath, ownerFileName(lockToken));
+    await readFile8(ownerPath, "utf8");
     const now = /* @__PURE__ */ new Date();
     await utimes(ownerPath, now, now);
   } catch {
@@ -18649,8 +18882,8 @@ async function refreshStateLock(lockPath, lockToken) {
 }
 async function releaseStateLock(lockPath, lockToken) {
   try {
-    const ownerPath = join8(lockPath, ownerFileName(lockToken));
-    await unlink2(ownerPath);
+    const ownerPath = join10(lockPath, ownerFileName(lockToken));
+    await unlink3(ownerPath);
     await rmdir(lockPath);
   } catch (error) {
     if (!isErrorCode(error, "ENOENT") && !isErrorCode(error, "ENOTEMPTY")) {
@@ -18663,8 +18896,8 @@ function ownerFileName(lockToken) {
 }
 var defaultCloneFailureStore = new FileCloneFailureStore();
 async function cloneFailureScope(source, destination) {
-  const sourcePath = resolve6(source);
-  const destinationParent = resolve6(dirname7(destination));
+  const sourcePath = resolve7(source);
+  const destinationParent = resolve7(dirname8(destination));
   const [sourceDevice, destinationDevice] = await Promise.all([
     readDevice(sourcePath),
     readDevice(destinationParent)
@@ -18691,7 +18924,7 @@ function isErrorCode(error, code) {
 // src/command-runner.ts
 import { spawn as spawn4 } from "node:child_process";
 var runCommand = async (command, cwd, stderr, stdout2 = (chunk) => process.stdout.write(chunk), options) => {
-  await new Promise((resolve12, reject) => {
+  await new Promise((resolve13, reject) => {
     const shell = options?.shell ?? true;
     const [executable, args] = shell ? [command, []] : splitCommand(command);
     const child = spawn4(executable, args, {
@@ -18710,7 +18943,7 @@ var runCommand = async (command, cwd, stderr, stdout2 = (chunk) => process.stdou
       if (code !== 0) {
         reject(new Error(`exited with code ${code}`));
       } else {
-        resolve12();
+        resolve13();
       }
     });
     child.on("error", reject);
@@ -18734,22 +18967,22 @@ import {
   chmod,
   cp,
   lstat as lstat3,
-  mkdir as mkdir7,
+  mkdir as mkdir8,
   mkdtemp as mkdtemp2,
   opendir,
   readdir as readdir2,
-  readFile as readFile7,
+  readFile as readFile9,
   readlink,
   realpath as realpath2,
   rename as rename4,
   rm as rm4,
   rmdir as rmdir2,
   symlink,
-  unlink as unlink3,
+  unlink as unlink4,
   utimes as utimes2,
-  writeFile as writeFile7
+  writeFile as writeFile9
 } from "node:fs/promises";
-import { basename as basename6, dirname as dirname8, join as join10 } from "node:path";
+import { basename as basename6, dirname as dirname9, join as join12 } from "node:path";
 import { promisify as promisify6 } from "node:util";
 
 // src/fs-utils.ts
@@ -18778,20 +19011,20 @@ function hasErrorCode(error, code) {
 
 // src/safe-destination.ts
 import { constants as constants4 } from "node:fs";
-import { lstat as lstat2, mkdir as mkdir6, open as open2 } from "node:fs/promises";
-import { isAbsolute as isAbsolute3, join as join9, relative, resolve as resolve7, sep } from "node:path";
+import { lstat as lstat2, mkdir as mkdir7, open as open2 } from "node:fs/promises";
+import { isAbsolute as isAbsolute3, join as join11, relative, resolve as resolve8, sep } from "node:path";
 async function openDestinationDirectory(root, path9) {
   const segments = destinationSegments(root, path9);
   if (process.platform !== "linux") {
     await ensureDestinationDirectory(root, path9);
-    return { path: resolve7(path9), close: async () => void 0 };
+    return { path: resolve8(path9), close: async () => void 0 };
   }
   let handle = await open2(root, destinationDirectoryFlags());
   try {
     for (const segment of segments) {
-      const childPath = join9(fileDescriptorPath(handle.fd), segment);
+      const childPath = join11(fileDescriptorPath(handle.fd), segment);
       try {
-        await mkdir6(childPath);
+        await mkdir7(childPath);
       } catch (error) {
         if (!isAlreadyExistsError(error)) throw error;
       }
@@ -18809,8 +19042,8 @@ async function openDestinationDirectory(root, path9) {
   }
 }
 async function inspectDestination(root, path9) {
-  const resolvedPath = resolve7(path9);
-  const resolvedRoot = resolve7(root);
+  const resolvedPath = resolve8(path9);
+  const resolvedRoot = resolve8(root);
   const distance = relative(resolvedRoot, resolvedPath);
   if (isAbsolute3(distance) || distance === ".." || distance.startsWith(`..${sep}`)) {
     return { kind: "unsafe", reason: "destination escapes the worktree" };
@@ -18827,7 +19060,7 @@ async function inspectDestination(root, path9) {
   }
   const segments = distance.split(sep).filter(Boolean);
   for (const [index, segment] of segments.entries()) {
-    current = resolve7(current, segment);
+    current = resolve8(current, segment);
     try {
       const stats = await lstat2(current);
       if (stats.isSymbolicLink()) {
@@ -18868,8 +19101,8 @@ async function inspectDestination(root, path9) {
   }
 }
 function destinationSegments(root, path9) {
-  const resolvedRoot = resolve7(root);
-  const resolvedPath = resolve7(path9);
+  const resolvedRoot = resolve8(root);
+  const resolvedPath = resolve8(path9);
   const distance = relative(resolvedRoot, resolvedPath);
   if (isAbsolute3(distance) || distance === ".." || distance.startsWith(`..${sep}`)) {
     throw new Error("destination escapes the worktree");
@@ -18887,8 +19120,8 @@ function fileDescriptorPath(fd) {
   );
 }
 async function ensureDestinationDirectory(root, path9) {
-  const resolvedRoot = resolve7(root);
-  const resolvedPath = resolve7(path9);
+  const resolvedRoot = resolve8(root);
+  const resolvedPath = resolve8(path9);
   const distance = relative(resolvedRoot, resolvedPath);
   if (isAbsolute3(distance) || distance === ".." || distance.startsWith(`..${sep}`)) {
     throw new Error("destination escapes the worktree");
@@ -18899,7 +19132,7 @@ async function ensureDestinationDirectory(root, path9) {
     throw new Error("worktree root is not a directory");
   }
   for (const segment of distance.split(sep).filter(Boolean)) {
-    current = resolve7(current, segment);
+    current = resolve8(current, segment);
     try {
       const stats = await lstat2(current);
       if (stats.isSymbolicLink() || !stats.isDirectory()) {
@@ -18908,7 +19141,7 @@ async function ensureDestinationDirectory(root, path9) {
     } catch (error) {
       if (!isNotFoundError(error)) throw error;
       try {
-        await mkdir6(current);
+        await mkdir7(current);
       } catch (mkdirError) {
         if (!isAlreadyExistsError(mkdirError)) throw mkdirError;
       }
@@ -18941,7 +19174,7 @@ async function cloneDir(source, destination, options = {}) {
     throw new CloneDestinationExistsError(destination);
   }
   const startedAt = Date.now();
-  const parent = dirname8(destination);
+  const parent = dirname9(destination);
   let safeParent;
   try {
     if (options.destinationRoot) {
@@ -18957,10 +19190,10 @@ async function cloneDir(source, destination, options = {}) {
         parent
       );
     } else {
-      await mkdir7(parent, { recursive: true });
+      await mkdir8(parent, { recursive: true });
     }
     const operationParent = safeParent?.path ?? parent;
-    const operationDestination = join10(operationParent, basename6(destination));
+    const operationDestination = join12(operationParent, basename6(destination));
     if (await destinationExists(operationDestination)) {
       throw new CloneDestinationExistsError(destination);
     }
@@ -18973,9 +19206,9 @@ async function cloneDir(source, destination, options = {}) {
     try {
       reservationPath = await reserveDestination(operationDestination);
       temporaryRoot = await mkdtemp2(
-        join10(operationParent, `.${basename6(destination)}.gji-clone-`)
+        join12(operationParent, `.${basename6(destination)}.gji-clone-`)
       );
-      const temporaryDestination = join10(temporaryRoot, basename6(destination));
+      const temporaryDestination = join12(temporaryRoot, basename6(destination));
       const copyDirectory = options.copyDirectory ?? (platformIsDarwin(platform3) ? runNativeCloneDirectory : async (source2, target) => {
         if (!strategy) {
           throw new CloneUnsupportedError(
@@ -19083,7 +19316,7 @@ async function directorySize(path9) {
         if (entryCount > SIZE_ESTIMATE_MAX_ENTRIES || Date.now() - startedAt > SIZE_ESTIMATE_MAX_MS) {
           throw new Error("directory size estimate exceeded its safety limit");
         }
-        const entryPath = join10(current, entry.name);
+        const entryPath = join12(current, entry.name);
         if (entry.isDirectory()) pending.push(entryPath);
         else total += (await lstat3(entryPath)).size;
       }
@@ -19128,10 +19361,10 @@ async function acquireCloneLock(lockPath, destination) {
   const lockToken = randomUUID3();
   for (let attempt = 0; attempt < 3; attempt += 1) {
     try {
-      await mkdir7(lockPath);
+      await mkdir8(lockPath);
       try {
-        await writeFile7(
-          join10(lockPath, ownerFileName2(lockToken)),
+        await writeFile9(
+          join12(lockPath, ownerFileName2(lockToken)),
           `${lockToken}
 `,
           {
@@ -19164,10 +19397,10 @@ async function acquireCloneLock(lockPath, destination) {
       throw error;
     }
     try {
-      await mkdir7(lockPath);
+      await mkdir8(lockPath);
       try {
-        await writeFile7(
-          join10(lockPath, ownerFileName2(lockToken)),
+        await writeFile9(
+          join12(lockPath, ownerFileName2(lockToken)),
           `${lockToken}
 `,
           {
@@ -19199,7 +19432,7 @@ async function lockFreshnessPath2(lockPath) {
   try {
     const entries = await readdir2(lockPath);
     const owner = entries.find((entry) => entry.startsWith("owner-"));
-    return owner ? join10(lockPath, owner) : lockPath;
+    return owner ? join12(lockPath, owner) : lockPath;
   } catch (error) {
     if (isNotFoundError(error)) throw error;
     return lockPath;
@@ -19214,19 +19447,19 @@ async function publishCloneContents(temporaryDestination, destination, reservati
   const temporaryEntries = await readdir2(temporaryDestination);
   for (const entry of temporaryEntries) {
     await publishCloneEntry(
-      join10(temporaryDestination, entry),
-      join10(destination, entry),
+      join12(temporaryDestination, entry),
+      join12(destination, entry),
       () => onEntryPublished(entry),
       copyFileEntry
     );
   }
-  await unlink3(reservationPath);
+  await unlink4(reservationPath);
 }
 async function publishCloneEntry(source, destination, onCreated, copyFileEntry) {
   const sourceStats = await lstat3(source);
   if (sourceStats.isDirectory()) {
     try {
-      await mkdir7(destination);
+      await mkdir8(destination);
     } catch (error) {
       if (isAlreadyExistsError(error)) {
         throw new CloneDestinationExistsError(destination);
@@ -19236,8 +19469,8 @@ async function publishCloneEntry(source, destination, onCreated, copyFileEntry)
     onCreated();
     for (const entry of await readdir2(source)) {
       await publishCloneEntry(
-        join10(source, entry),
-        join10(destination, entry),
+        join12(source, entry),
+        join12(destination, entry),
         () => void 0,
         copyFileEntry
       );
@@ -19288,19 +19521,19 @@ async function copyCloneMetadata(sourceStats, destination) {
 }
 async function reserveDestination(destination) {
   try {
-    await mkdir7(destination);
+    await mkdir8(destination);
   } catch (error) {
     if (isAlreadyExistsError(error)) {
       throw new CloneDestinationExistsError(destination);
     }
     throw error;
   }
-  const reservationPath = join10(
+  const reservationPath = join12(
     destination,
     `.gji-clone-reservation-${randomUUID3()}`
   );
   try {
-    await writeFile7(reservationPath, "gji clone reservation\n", {
+    await writeFile9(reservationPath, "gji clone reservation\n", {
       flag: "wx"
     });
     return reservationPath;
@@ -19340,8 +19573,8 @@ function startLockHeartbeat(lockPath, lockToken) {
 }
 async function refreshCloneLock(lockPath, lockToken) {
   try {
-    const ownerPath = join10(lockPath, ownerFileName2(lockToken));
-    await readFile7(ownerPath, "utf8");
+    const ownerPath = join12(lockPath, ownerFileName2(lockToken));
+    await readFile9(ownerPath, "utf8");
     const now = /* @__PURE__ */ new Date();
     await utimes2(ownerPath, now, now);
   } catch {
@@ -19349,8 +19582,8 @@ async function refreshCloneLock(lockPath, lockToken) {
 }
 async function releaseCloneLock(lockPath, lockToken) {
   try {
-    const ownerPath = join10(lockPath, ownerFileName2(lockToken));
-    await unlink3(ownerPath);
+    const ownerPath = join12(lockPath, ownerFileName2(lockToken));
+    await unlink4(ownerPath);
     await rmdir2(lockPath);
   } catch (error) {
     if (!isNotFoundError(error) && !isDirectoryNotEmptyError(error))
@@ -19807,7 +20040,7 @@ function createBootstrapAdapters(checkUvRuntime, cargoBuildCommand) {
       shell: false,
       beforeRepair: async (target) => {
         if (!target.existingBeforeBootstrap) {
-          await rm5(join11(target.targetPath, ".modules.yaml"), {
+          await rm5(join13(target.targetPath, ".modules.yaml"), {
             force: true
           });
         }
@@ -19891,9 +20124,9 @@ var LockfileBootstrapAdapter = class {
   }
   async detect(context) {
     const detectionRoot = context.detectionRoot ?? context.sourceRoot;
-    if (!await pathExists2(join11(detectionRoot, this.lockfile))) return null;
-    const sourcePath = join11(context.sourceRoot, this.relativePath);
-    const targetPath = join11(context.worktreePath, this.relativePath);
+    if (!await pathExists2(join13(detectionRoot, this.lockfile))) return null;
+    const sourcePath = join13(context.sourceRoot, this.relativePath);
+    const targetPath = join13(context.worktreePath, this.relativePath);
     const destinationInspection = await inspectDestination(
       context.worktreePath,
       targetPath
@@ -19974,13 +20207,13 @@ async function safeSourceDirectory(target) {
 }
 async function defaultCheckUvRuntime(target) {
   try {
-    const config = await readFile8(
-      join11(target.sourcePath, "pyvenv.cfg"),
+    const config = await readFile10(
+      join13(target.sourcePath, "pyvenv.cfg"),
       "utf8"
     );
     const expected = config.match(/^version\s*=\s*(\d+\.\d+)/mu)?.[1];
     if (!expected) return false;
-    const sourceInterpreter = join11(
+    const sourceInterpreter = join13(
       target.sourcePath,
       process.platform === "win32" ? "Scripts/python.exe" : "bin/python"
     );
@@ -20006,12 +20239,12 @@ async function isAllowedSourceRoot(repoRoot, sourceRoot) {
       realpath3(sourceRoot)
     ]);
     if (resolvedRepoRoot === resolvedSourceRoot) return true;
-    const gitFile = await readFile8(join11(resolvedSourceRoot, ".git"), "utf8");
+    const gitFile = await readFile10(join13(resolvedSourceRoot, ".git"), "utf8");
     const gitDirectory = gitFile.match(/^gitdir:\s*(.+)$/mu)?.[1];
     if (!gitDirectory) return false;
     return isWithin(
-      join11(resolvedRepoRoot, ".git", "worktrees"),
-      resolve8(resolvedSourceRoot, gitDirectory)
+      join13(resolvedRepoRoot, ".git", "worktrees"),
+      resolve9(resolvedSourceRoot, gitDirectory)
     );
   } catch {
     return false;
@@ -20186,12 +20419,12 @@ function toErrorMessage3(error) {
 
 // src/sync-plan.ts
 import { lstat as lstat5, realpath as realpath4 } from "node:fs/promises";
-import { isAbsolute as isAbsolute4, join as join12, relative as relative3, resolve as resolve9, sep as sep3 } from "node:path";
+import { isAbsolute as isAbsolute4, join as join14, relative as relative3, resolve as resolve10, sep as sep3 } from "node:path";
 async function prepareSyncDirectoryPlan(repoRoot, worktreePath, directories) {
   const normalizedDirectories = directories.map(validateSyncDirPattern).sort(directoryDepthAscending);
   const plan = [];
   for (const directory of normalizedDirectories) {
-    const destination = join12(worktreePath, directory);
+    const destination = join14(worktreePath, directory);
     const destinationState = await inspectDestination(
       worktreePath,
       destination
@@ -20265,7 +20498,7 @@ async function estimateSyncDirectories(repoRoot, worktreePath, directories) {
   return estimateSyncDirectoryPlan(plan);
 }
 async function resolveSyncDirectorySource(repoRoot, directory) {
-  const source = join12(repoRoot, directory);
+  const source = join14(repoRoot, directory);
   let resolvedSource;
   try {
     resolvedSource = await realpath4(source);
@@ -20291,7 +20524,7 @@ function directoryDepthAscending(left, right) {
   return left.split(/[\\/]+/u).length - right.split(/[\\/]+/u).length;
 }
 function isPathInside2(parent, child) {
-  const relativePath = relative3(resolve9(parent), resolve9(child));
+  const relativePath = relative3(resolve10(parent), resolve10(child));
   return relativePath !== "" && !isAbsolute4(relativePath) && relativePath !== ".." && !relativePath.startsWith(`..${sep3}`);
 }
 function toErrorMessage4(error) {
@@ -20306,12 +20539,12 @@ import { constants as constants7 } from "node:fs";
 import { copyFile, lstat as lstat6, realpath as realpath5 } from "node:fs/promises";
 import {
   basename as basename7,
-  dirname as dirname9,
+  dirname as dirname10,
   isAbsolute as isAbsolute5,
-  join as join13,
+  join as join15,
   normalize as normalize2,
   relative as relative4,
-  resolve as resolve10,
+  resolve as resolve11,
   sep as sep4
 } from "node:path";
 async function syncFiles(mainRoot, targetPath, patterns) {
@@ -20319,7 +20552,7 @@ async function syncFiles(mainRoot, targetPath, patterns) {
     const normalized = validateSyncFilePattern(pattern);
     const sourcePath = await resolveSyncFileSource(mainRoot, normalized);
     if (!sourcePath) continue;
-    const destPath = join13(targetPath, normalized);
+    const destPath = join15(targetPath, normalized);
     const existingDestination = await readDestinationEntry(destPath);
     if (existingDestination?.isSymbolicLink()) {
       throw new Error(`destination is a symbolic link: ${destPath}`);
@@ -20327,7 +20560,7 @@ async function syncFiles(mainRoot, targetPath, patterns) {
     if (existingDestination) {
       continue;
     }
-    const destinationParent = dirname9(destPath);
+    const destinationParent = dirname10(destPath);
     const beforeCreate = await inspectDestination(
       targetPath,
       destinationParent
@@ -20340,7 +20573,7 @@ async function syncFiles(mainRoot, targetPath, patterns) {
       destinationParent
     );
     try {
-      const safeDestination = join13(safeParent.path, basename7(destPath));
+      const safeDestination = join15(safeParent.path, basename7(destPath));
       const safeExistingDestination = await readDestinationEntry(safeDestination);
       if (safeExistingDestination?.isSymbolicLink()) {
         throw new Error(`destination is a symbolic link: ${destPath}`);
@@ -20376,7 +20609,7 @@ async function resolveSyncFileSource(mainRoot, pattern) {
   try {
     [resolvedRoot, resolvedSource] = await Promise.all([
       realpath5(mainRoot),
-      realpath5(join13(mainRoot, pattern))
+      realpath5(join15(mainRoot, pattern))
     ]);
   } catch (error) {
     if (isNotFoundError(error)) return void 0;
@@ -20390,7 +20623,7 @@ async function resolveSyncFileSource(mainRoot, pattern) {
   const sourceStats = await lstat6(resolvedSource);
   if (!sourceStats.isFile()) {
     throw new Error(
-      `syncFiles: source is not a file: ${join13(mainRoot, pattern)}`
+      `syncFiles: source is not a file: ${join15(mainRoot, pattern)}`
     );
   }
   return resolvedSource;
@@ -20404,13 +20637,13 @@ async function readDestinationEntry(path9) {
   }
 }
 function isPathInside3(root, candidate) {
-  const distance = relative4(resolve10(root), resolve10(candidate));
+  const distance = relative4(resolve11(root), resolve11(candidate));
   return distance === "" || !isAbsolute5(distance) && distance !== ".." && !distance.startsWith(`..${sep4}`);
 }
 
 // src/package-manager.ts
 import { access as access8, readdir as readdir3 } from "node:fs/promises";
-import { join as join14 } from "node:path";
+import { join as join16 } from "node:path";
 var ENTRIES = [
   // JavaScript / TypeScript
   { name: "pnpm", signals: ["pnpm-lock.yaml"], command: "pnpm install" },
@@ -20540,7 +20773,7 @@ async function detectPackageManager(repoRoot) {
 async function matchesExact(repoRoot, signals) {
   for (const signal of signals) {
     try {
-      await access8(join14(repoRoot, signal));
+      await access8(join16(repoRoot, signal));
       return true;
     } catch {
     }
@@ -20911,13 +21144,15 @@ async function bootstrapWorktree(options) {
     );
   }
   const hooks = extractHooks(options.config);
+  const slot = await assignWorktreeSlot(options.repoRoot, options.worktreePath);
   await runHook(
     hooks["after-create"],
     options.worktreePath,
     {
       branch: options.branch,
       path: options.worktreePath,
-      repo: basename8(options.repoRoot)
+      repo: basename8(options.repoRoot),
+      slot
     },
     options.reporter.write,
     options.json ? () => void 0 : options.commandStdout ?? ((chunk) => process.stdout.write(chunk))
@@ -21113,7 +21348,7 @@ ${dryRunSyncDirs.map(({ dir, bytes }) => `Would clone ${dir} (${formatBytes(byte
       }
       return 1;
     }
-    await mkdir8(dirname10(worktreePath), { recursive: true });
+    await mkdir9(dirname11(worktreePath), { recursive: true });
     const branchAlreadyExists = await localBranchExists(
       repository.repoRoot,
       branchName
@@ -21277,26 +21512,31 @@ async function writeOutput(worktreePath, stdout2, outputEnv) {
 }
 
 // src/worktree-sources.ts
+var MAX_REPOSITORY_DISCOVERY_CONCURRENCY = 4;
 async function listRegisteredWorktreeSources(cwd, onSkipped) {
   const registry = await loadRegistry();
   const currentRoot = await detectRepository(cwd).then((repository) => repository.currentRoot).catch(() => null);
-  const results = await Promise.allSettled(
-    registry.map(async (entry) => {
-      const worktrees = await listWorktrees(entry.path);
-      return { repoName: entry.name, repoRoot: entry.path, worktrees };
-    })
+  const results = await mapWithConcurrency3(
+    registry,
+    MAX_REPOSITORY_DISCOVERY_CONCURRENCY,
+    async (entry) => {
+      try {
+        const worktrees = await listWorktrees(entry.path);
+        return { entry, worktrees };
+      } catch {
+        onSkipped?.(entry);
+        return null;
+      }
+    }
   );
   const allItems = [];
-  for (const [index, result] of results.entries()) {
-    if (result.status === "rejected") {
-      onSkipped?.(registry[index]);
-      continue;
-    }
-    const { repoName, repoRoot, worktrees } = result.value;
+  for (const result of results) {
+    if (result === null) continue;
+    const { entry, worktrees } = result;
     for (const worktree of worktrees) {
       allItems.push({
-        repoRoot,
-        repoName,
+        repoRoot: entry.path,
+        repoName: entry.name,
         worktree: {
           ...worktree,
           isCurrent: currentRoot !== null && worktree.path === currentRoot
@@ -21306,6 +21546,44 @@ async function listRegisteredWorktreeSources(cwd, onSkipped) {
   }
   return allItems;
 }
+async function listDiscoverableWorktreeSources(cwd, onSkipped) {
+  const currentRepository = await detectRepository(cwd).catch(() => null);
+  const registeredSources = await listRegisteredWorktreeSources(cwd, onSkipped);
+  if (currentRepository === null) return dedupeSources(registeredSources);
+  let currentSources = [];
+  try {
+    currentSources = (await listWorktrees(cwd)).map((worktree) => ({
+      repoName: currentRepository.repoName,
+      repoRoot: currentRepository.repoRoot,
+      worktree
+    }));
+  } catch {
+  }
+  return dedupeSources([...currentSources, ...registeredSources]);
+}
+async function mapWithConcurrency3(items, limit, mapper) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  async function readNext() {
+    for (; ; ) {
+      const index = nextIndex++;
+      if (index >= items.length) return;
+      results[index] = await mapper(items[index]);
+    }
+  }
+  await Promise.all(
+    Array.from({ length: Math.min(limit, items.length) }, () => readNext())
+  );
+  return results;
+}
+function dedupeSources(sources) {
+  const seen = /* @__PURE__ */ new Set();
+  return sources.filter((source) => {
+    if (seen.has(source.worktree.path)) return false;
+    seen.add(source.worktree.path);
+    return true;
+  });
+}
 
 // src/go-resolver.ts
 async function resolveGoBranch(options) {
@@ -21487,8 +21765,8 @@ function normalizeRemoteUrl(value) {
 
 // src/new.ts
 import { execFile as execFile8 } from "node:child_process";
-import { access as access9, mkdir as mkdir9 } from "node:fs/promises";
-import { dirname as dirname11, resolve as resolve11 } from "node:path";
+import { access as access9, mkdir as mkdir10 } from "node:fs/promises";
+import { dirname as dirname12, resolve as resolve12 } from "node:path";
 import { promisify as promisify9 } from "node:util";
 var execFileAsync8 = promisify9(execFile8);
 var NEW_OUTPUT_FILE_ENV = "GJI_NEW_OUTPUT_FILE";
@@ -21742,7 +22020,7 @@ ${dryRunSyncDirs.map(({ dir, bytes }) => `Would clone ${dir} (${formatBytes(byte
       }
       return 0;
     }
-    await mkdir9(dirname11(worktreePath), { recursive: true });
+    await mkdir10(dirname12(worktreePath), { recursive: true });
     const startPoint = options.fromCurrent && !options.detached ? await resolveCurrentWorktreeHead(options.cwd) : void 0;
     const takeStartPoint = options.take ? await resolveCurrentWorktreeHead(options.cwd) : void 0;
     const changedTakeFiles = options.take ? await listTakeFiles(options.cwd) : [];
@@ -21842,6 +22120,16 @@ ${dryRunSyncDirs.map(({ dir, bytes }) => `Would clone ${dir} (${formatBytes(byte
         `could not apply taken changes; your changes are safe in stash: ${stashSha}`
       );
     }
+    if (options.task !== void 0) {
+      try {
+        await writeTask(worktreePath, options.task);
+      } catch (error) {
+        options.stderr(
+          `Warning: could not save task metadata: ${error instanceof Error ? error.message : String(error)}
+`
+        );
+      }
+    }
     const bootstrap = await bootstrapWorktree({
       branch: worktreeName,
       cloneDirectory,
@@ -22165,7 +22453,7 @@ async function detectInProgressGitState(cwd) {
         ["rev-parse", "--git-path", marker],
         { cwd }
       );
-      await access9(resolve11(cwd, stdout2.trim()));
+      await access9(resolve12(cwd, stdout2.trim()));
       return name;
     } catch {
     }
@@ -22579,10 +22867,16 @@ async function navigateToExistingWorktree(options, path9, worktree) {
     {
       branch: worktree?.branch ?? void 0,
       path: path9,
-      repo: basename9(repository.repoRoot)
+      repo: basename9(repository.repoRoot),
+      slot: await getWorktreeSlot(path9)
     },
     options.stderr
   );
+  if (!options.quiet) {
+    const card = await renderContextCard(path9);
+    if (card) options.stderr(`${card}
+`);
+  }
   await recordWorktreeUsage(path9, worktree?.branch ?? null);
   await writeShellOutput(GO_OUTPUT_FILE_ENV, path9, options.stdout);
   return 0;
@@ -22710,11 +23004,288 @@ async function runHistoryCommand(options) {
   return 0;
 }
 
+// src/hub.ts
+import { basename as basename10 } from "node:path";
+var MAX_HUB_REPOSITORY_CONCURRENCY = 4;
+var defaultDependencies = {
+  queryRepositoryPullRequests: createPullRequestQuery().listOpenPullRequestsForRepository
+};
+async function buildHubData(cwd, dependencies = {}) {
+  const queryRepositoryPullRequests = dependencies.queryRepositoryPullRequests ?? defaultDependencies.queryRepositoryPullRequests;
+  const currentRepository = await detectRepository(cwd).catch(() => null);
+  const history = await loadHistory();
+  const lastUsedByPath = new Map(
+    history.map((entry) => [entry.path, entry.timestamp])
+  );
+  const sources = await listDiscoverableWorktreeSources(cwd);
+  const groups = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    if (!source.repoRoot) continue;
+    const repoRoot = source.repoRoot;
+    const existing = groups.get(repoRoot);
+    if (existing) {
+      existing.sources.push(source);
+    } else {
+      groups.set(repoRoot, {
+        name: source.repoName || basename10(repoRoot),
+        sources: [source]
+      });
+    }
+  }
+  const repositories = await mapWithConcurrency4(
+    [...groups.entries()],
+    MAX_HUB_REPOSITORY_CONCURRENCY,
+    async ([root, group]) => {
+      const infos = await readWorktreeInfos(
+        group.sources.map((source) => source.worktree)
+      );
+      let pullRequests = [];
+      try {
+        pullRequests = await queryRepositoryPullRequests(root);
+      } catch {
+      }
+      const worktrees = infos.map((info) => ({
+        ...info,
+        lastUsedTimestamp: lastUsedByPath.get(info.path) ?? null,
+        pullRequests: pullRequests.filter(
+          (pullRequest) => pullRequest.sourceBranch === info.branch
+        )
+      }));
+      return {
+        current: currentRepository?.repoRoot === root,
+        name: group.name,
+        pullRequests,
+        root,
+        worktrees
+      };
+    }
+  );
+  repositories.sort((left, right) => {
+    if (left.current !== right.current) return left.current ? -1 : 1;
+    return left.name.localeCompare(right.name);
+  });
+  return {
+    currentRepository: currentRepository?.repoRoot ?? null,
+    repositories
+  };
+}
+async function runHubCommand(options, dependencies = {}) {
+  const data = await buildHubData(options.cwd, dependencies);
+  if (options.json) {
+    options.stdout(`${JSON.stringify(data, null, 2)}
+`);
+    return 0;
+  }
+  options.stdout(
+    `${formatHubOutput(
+      data,
+      options.columns ?? process.stdout.columns ?? 80,
+      options.now ?? Date.now()
+    )}
+`
+  );
+  return 0;
+}
+function formatHubOutput(data, columns = process.stdout.columns ?? 80, now = Date.now()) {
+  if (data.repositories.length === 0) {
+    return "No registered repositories. Run gji from a repository to add one.";
+  }
+  const lineWidth = Math.max(1, columns);
+  const allWorktrees = data.repositories.flatMap(
+    (repository) => repository.worktrees.map((worktree) => ({ repository, worktree }))
+  );
+  const attention = allWorktrees.filter(
+    ({ worktree }) => isActionable(worktree)
+  );
+  const current = allWorktrees.find(({ worktree }) => worktree.isCurrent) ?? null;
+  const next = chooseNextWorktree(allWorktrees);
+  const remainingAttention = attention.filter(
+    (entry) => entry !== current && entry !== next
+  );
+  const quiet = allWorktrees.filter(
+    (entry) => entry !== current && entry !== next && !attention.includes(entry)
+  );
+  const recentOther = [...quiet].sort(
+    (left, right) => (right.worktree.lastCommitTimestamp ?? 0) - (left.worktree.lastCommitTimestamp ?? 0)
+  ).slice(0, 5);
+  const hiddenCount = quiet.length - recentOther.length;
+  const lines = [
+    `GJI  ${data.repositories.length} repositories \xB7 ${allWorktrees.length} worktrees${attention.length > 0 ? ` \xB7 ${attention.length} need attention` : ""}`,
+    ""
+  ];
+  if (data.repositories.length > 1) {
+    lines.push("REPOSITORIES");
+    for (const repository of data.repositories) {
+      lines.push(formatRepositorySummary(repository, lineWidth));
+    }
+    lines.push("");
+  }
+  if (current !== null) {
+    lines.push("CURRENT");
+    lines.push(...formatHubWorktree(current, lineWidth, "@", now));
+    lines.push("");
+  }
+  if (next !== null && next !== current) {
+    lines.push("NEXT");
+    lines.push(...formatHubWorktree(next, lineWidth, "\u203A", now));
+    lines.push("");
+  }
+  if (remainingAttention.length > 0) {
+    lines.push("ATTENTION");
+    for (const entry of remainingAttention) {
+      lines.push(...formatHubWorktree(entry, lineWidth, "!", now));
+    }
+    lines.push("");
+  }
+  if (recentOther.length > 0) {
+    lines.push("OTHER");
+    for (const entry of recentOther) {
+      lines.push(...formatHubWorktree(entry, lineWidth, " ", now));
+    }
+    if (hiddenCount > 0) {
+      lines.push(
+        `  ${hiddenCount} quiet worktree${hiddenCount === 1 ? "" : "s"} hidden`
+      );
+    }
+    lines.push("");
+  }
+  if (next === null && remainingAttention.length === 0 && recentOther.length === 0) {
+    lines.push("No active worktrees.");
+  }
+  lines.push("Run `gji go <repo>/<branch>` to switch worktrees.");
+  return lines.map(
+    (line) => terminalWidth(line) > lineWidth ? middleEllipsize(line, lineWidth) : line
+  ).join("\n").trimEnd();
+}
+function formatRepositorySummary(repository, lineWidth) {
+  const attentionCount = repository.worktrees.filter(isActionable).length;
+  const attention = attentionCount === 0 ? "healthy" : `${attentionCount} attention`;
+  const marker = repository.current ? "*" : " ";
+  return middleEllipsize(
+    `${marker} ${repository.name} \xB7 ${repository.worktrees.length} worktree${repository.worktrees.length === 1 ? "" : "s"} \xB7 ${attention}`,
+    lineWidth
+  );
+}
+function chooseNextWorktree(entries) {
+  return [...entries].sort((left, right) => {
+    const scoreDifference = nextWorktreeScore(right) - nextWorktreeScore(left);
+    if (scoreDifference !== 0) return scoreDifference;
+    const lastUsedDifference = (right.worktree.lastUsedTimestamp ?? 0) - (left.worktree.lastUsedTimestamp ?? 0);
+    if (lastUsedDifference !== 0) return lastUsedDifference;
+    return (right.worktree.lastCommitTimestamp ?? 0) - (left.worktree.lastCommitTimestamp ?? 0);
+  })[0] ?? null;
+}
+function nextWorktreeScore(entry) {
+  const { worktree } = entry;
+  let score = worktree.isCurrent && (worktree.task !== null || isActionable(worktree)) ? 100 : 0;
+  if (worktree.task !== null) score += 40;
+  if (worktree.status === "dirty") score += 30;
+  if (worktree.upstream.kind === "stale") score += 25;
+  if (worktree.upstream.kind === "tracked" && worktree.upstream.behind > 0) {
+    score += 25;
+  }
+  if (worktree.pullRequests.length > 0) score += 20;
+  if (worktree.lastUsedTimestamp !== null && worktree.lastUsedTimestamp > 0) {
+    score += 15;
+  }
+  return score;
+}
+function isActionable(worktree) {
+  return worktree.status === "dirty" || worktree.upstream.kind === "stale" || worktree.upstream.kind === "tracked" && worktree.upstream.behind > 0 || worktree.pullRequests.length > 0;
+}
+function formatHubWorktree(entry, lineWidth, marker, now) {
+  const { repository, worktree } = entry;
+  const branch = worktree.branch ?? "(detached)";
+  const status = [
+    formatWorktreeHealth(worktree),
+    formatWorktreeUpstream(worktree),
+    worktree.pullRequests.length > 0 ? worktree.pullRequests.map(
+      (pullRequest) => pullRequest.title ? `#${pullRequest.number} ${formatHumanText(pullRequest.title, 60)}` : `#${pullRequest.number}`
+    ).join(", ") : null,
+    formatWorktreeActivity(worktree, now)
+  ].filter((value) => value !== null).join(" \xB7 ");
+  const task = worktree.task === null ? null : `task: ${formatHumanText(worktree.task, 80)}`;
+  const target = `${repository.name}/${branch}`;
+  const lines = [`${marker} ${middleEllipsize(target, lineWidth - 2)}`];
+  if (status.length > 0) {
+    lines.push(`  ${middleEllipsize(status, lineWidth - 2)}`);
+  }
+  if (task !== null) {
+    lines.push(`  ${middleEllipsize(task, lineWidth - 2)}`);
+  }
+  if (marker === "@" || marker === "\u203A" || marker === "!") {
+    lines.push(`  ${middleEllipsize(nextAction(worktree), lineWidth - 2)}`);
+  }
+  return lines;
+}
+function formatWorktreeHealth(worktree) {
+  if (worktree.status === "dirty") return "! dirty";
+  if (worktree.status === "unknown") return "? health unknown";
+  return null;
+}
+function formatWorktreeUpstream(worktree) {
+  if (worktree.upstream.kind === "stale") return "! stale upstream";
+  if (worktree.upstream.kind === "tracked" && (worktree.upstream.behind > 0 || worktree.upstream.ahead > 0)) {
+    return formatUpstreamState(worktree.upstream);
+  }
+  return null;
+}
+function formatWorktreeActivity(worktree, now) {
+  if (worktree.isCurrent) return null;
+  const timestamps = [
+    worktree.lastUsedTimestamp ?? 0,
+    (worktree.lastCommitTimestamp ?? 0) * 1e3
+  ].filter((timestamp) => timestamp > 0);
+  if (timestamps.length === 0) return null;
+  const latest = Math.max(...timestamps);
+  const ageSeconds = Math.floor((now - latest) / 1e3);
+  if (ageSeconds < 24 * 60 * 60) return null;
+  return `inactive ${formatRelativeAge(
+    Math.floor(latest / 1e3),
+    Math.floor(now / 1e3)
+  )}`;
+}
+function nextAction(worktree) {
+  if (worktree.isCurrent && worktree.task !== null) {
+    return "next: continue task";
+  }
+  if (worktree.status === "dirty") {
+    return "next: switch \u2192 inspect changes";
+  }
+  if (worktree.upstream.kind === "stale" || worktree.upstream.kind === "tracked" && worktree.upstream.behind > 0) {
+    return "next: switch \u2192 sync";
+  }
+  const pullRequest = worktree.pullRequests[0];
+  if (pullRequest !== void 0) {
+    return `next: switch \u2192 open PR '#${pullRequest.number}'`;
+  }
+  return "next: switch worktree";
+}
+function formatHumanText(value, maxLength) {
+  const sanitized = sanitizeTerminalText(value);
+  return sanitized.length <= maxLength ? sanitized : `${sanitized.slice(0, Math.max(0, maxLength - 1))}\u2026`;
+}
+async function mapWithConcurrency4(items, limit, mapper) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  async function readNext() {
+    for (; ; ) {
+      const index = nextIndex++;
+      if (index >= items.length) return;
+      results[index] = await mapper(items[index]);
+    }
+  }
+  await Promise.all(
+    Array.from({ length: Math.min(limit, items.length) }, () => readNext())
+  );
+  return results;
+}
+
 // src/init.ts
 import { constants as constants8 } from "node:fs";
-import { access as access10, mkdir as mkdir10, readFile as readFile9, writeFile as writeFile8 } from "node:fs/promises";
-import { homedir as homedir8 } from "node:os";
-import { dirname as dirname12 } from "node:path";
+import { access as access10, mkdir as mkdir11, readFile as readFile11, writeFile as writeFile10 } from "node:fs/promises";
+import { homedir as homedir9 } from "node:os";
+import { dirname as dirname13 } from "node:path";
 var ZSH_COMPLETION_PATH_LINE = "fpath=(~/.zsh/completions $fpath)";
 var SHELL_WRAPPED_COMMANDS = [
   {
@@ -22784,7 +23355,7 @@ async function runOnboardingInitCommand(options) {
   if (options.json || isHeadless() || !canRunOnboarding(options)) {
     return writeNonInteractiveInitError(options);
   }
-  const home = options.home ?? homedir8();
+  const home = options.home ?? homedir9();
   const context = {
     detectedShell: resolveSupportedShell(void 0, process.env.SHELL),
     home
@@ -22838,8 +23409,8 @@ async function runDefaultOnboarding(context) {
   const installCompletion = await promptForCompletion(shell, completionPath);
   if (installCompletion === null) return abortDefaultOnboarding();
   if (installCompletion) {
-    await mkdir10(dirname12(completionPath), { recursive: true });
-    await writeFile8(completionPath, renderShellCompletion(shell), "utf8");
+    await mkdir11(dirname13(completionPath), { recursive: true });
+    await writeFile10(completionPath, renderShellCompletion(shell), "utf8");
   }
   if (shell === "zsh" && (completionAlreadyInstalled || installCompletion)) {
     await ensureZshCompletionPath(rcPath);
@@ -22931,8 +23502,8 @@ async function applyOnboardingResult(result, home) {
   const completionAlreadyInstalled = await fileExists(completionPath);
   await applyShellIntegration(result.shell, result.shellIntegration, home);
   if (result.installCompletion) {
-    await mkdir10(dirname12(completionPath), { recursive: true });
-    await writeFile8(
+    await mkdir11(dirname13(completionPath), { recursive: true });
+    await writeFile10(
       completionPath,
       renderShellCompletion(result.shell),
       "utf8"
@@ -22947,17 +23518,17 @@ async function applyOnboardingResult(result, home) {
 }
 async function installOnboardingShellIntegration(shell, home) {
   const rcPath = resolveShellConfigPath(shell, home);
-  await mkdir10(dirname12(rcPath), { recursive: true });
+  await mkdir11(dirname13(rcPath), { recursive: true });
   const current = await readExistingConfig(rcPath);
   if (shell === "fish") {
-    await writeFile8(
+    await writeFile10(
       rcPath,
       upsertShellIntegration(current, renderShellIntegration(shell)),
       "utf8"
     );
     return;
   }
-  await writeFile8(
+  await writeFile10(
     rcPath,
     upsertOnboardingShellIntegration(current, shell),
     "utf8"
@@ -22991,7 +23562,7 @@ async function ensureZshCompletionPath(rcPath) {
   const current = await readExistingConfig(rcPath);
   const next = upsertZshCompletionPath(current);
   if (next !== current) {
-    await writeFile8(rcPath, next, "utf8");
+    await writeFile10(rcPath, next, "utf8");
   }
 }
 function upsertZshCompletionPath(existingConfig) {
@@ -23022,7 +23593,7 @@ async function fileExists(path9) {
 }
 async function runLegacyInitCommand(options) {
   const shell = resolveSupportedShell(options.shell, process.env.SHELL);
-  const home = options.home ?? homedir8();
+  const home = options.home ?? homedir9();
   if (!shell) {
     options.stderr?.(
       "Unable to detect a supported shell. Specify one explicitly: bash, fish, or zsh.\n"
@@ -23035,10 +23606,10 @@ async function runLegacyInitCommand(options) {
     return 0;
   }
   const rcPath = resolveShellConfigPath(shell, home);
-  await mkdir10(dirname12(rcPath), { recursive: true });
+  await mkdir11(dirname13(rcPath), { recursive: true });
   const current = await readExistingConfig(rcPath);
   const next = upsertShellIntegration(current, script);
-  await writeFile8(rcPath, next, "utf8");
+  await writeFile10(rcPath, next, "utf8");
   options.stdout(`${rcPath}
 `);
   const { config: globalConfig } = await loadGlobalConfig(home);
@@ -23129,7 +23700,7 @@ async function saveWizardConfig(result, cwd, home) {
 }
 async function readExistingConfig(path9) {
   try {
-    return await readFile9(path9, "utf8");
+    return await readFile11(path9, "utf8");
   } catch (error) {
     if (isMissingFileError3(error)) {
       return "";
@@ -23317,6 +23888,7 @@ function formatDetailedWorktreeTable(worktrees) {
     lastCommit: formatLastCommit(worktree.lastCommitTimestamp),
     path: worktree.path,
     status: worktree.status,
+    task: worktree.task,
     upstream: formatUpstreamState(worktree.upstream)
   }));
   const branchWidth = Math.max(
@@ -23335,12 +23907,17 @@ function formatDetailedWorktreeTable(worktrees) {
     "LAST".length,
     ...rows.map((row) => row.lastCommit.length)
   );
+  const hasTasks = rows.some((row) => row.task !== null);
+  const taskWidth = Math.max(
+    "TASK".length,
+    ...rows.map((row) => row.task?.slice(0, 40).length ?? 0)
+  );
   const lines = [
-    "  " + "BRANCH".padEnd(branchWidth, " ") + " " + "STATUS".padEnd(statusWidth, " ") + " " + "UPSTREAM".padEnd(upstreamWidth, " ") + " " + "LAST".padEnd(lastCommitWidth, " ") + " PATH"
+    "  " + "BRANCH".padEnd(branchWidth, " ") + " " + "STATUS".padEnd(statusWidth, " ") + " " + "UPSTREAM".padEnd(upstreamWidth, " ") + " " + "LAST".padEnd(lastCommitWidth, " ") + (hasTasks ? " " + "TASK".padEnd(taskWidth, " ") : "") + " PATH"
   ];
   for (const row of rows) {
     lines.push(
-      `${row.isCurrent ? "*" : " "} ${row.branch.padEnd(branchWidth, " ")} ${row.status.padEnd(statusWidth, " ")} ${row.upstream.padEnd(upstreamWidth, " ")} ${row.lastCommit.padEnd(lastCommitWidth, " ")} ` + row.path
+      `${row.isCurrent ? "*" : " "} ${row.branch.padEnd(branchWidth, " ")} ${row.status.padEnd(statusWidth, " ")} ${row.upstream.padEnd(upstreamWidth, " ")} ${row.lastCommit.padEnd(lastCommitWidth, " ")}` + (hasTasks ? ` ${(row.task?.slice(0, 40) ?? "").padEnd(taskWidth, " ")}` : "") + " " + row.path
     );
   }
   return lines.join("\n");
@@ -23373,8 +23950,8 @@ function sortWorktrees(worktrees) {
 
 // src/open.ts
 import { execFile as execFile9 } from "node:child_process";
-import { access as access11, writeFile as writeFile9 } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { access as access11, writeFile as writeFile11 } from "node:fs/promises";
+import { join as join17 } from "node:path";
 import { promisify as promisify10 } from "node:util";
 var execFileAsync9 = promisify10(execFile9);
 function createOpenCommand(dependencies = {}) {
@@ -23541,14 +24118,14 @@ async function defaultPromptForEditor(editors) {
   return choice;
 }
 async function ensureWorkspaceFile(worktreePath, repoName) {
-  const workspacePath = join15(worktreePath, `${repoName}.code-workspace`);
+  const workspacePath = join17(worktreePath, `${repoName}.code-workspace`);
   try {
     await access11(workspacePath);
     return workspacePath;
   } catch {
   }
   const workspace = { folders: [{ path: "." }], settings: {} };
-  await writeFile9(
+  await writeFile11(
     workspacePath,
     `${JSON.stringify(workspace, null, 2)}
 `,
@@ -23773,7 +24350,7 @@ async function openFromWorktreeSelector(repoRoot, repoName, options, promptForWo
     queryPullRequests: async (_root, branch) => pullRequestsByBranch.get(branch) ?? []
   });
   const connectedEntries = entries.filter(
-    (entry) => (entry.pullRequestNumbers?.length ?? 0) > 0
+    (entry) => (entry.pullRequests?.length ?? 0) > 0
   );
   if (connectedEntries.length === 0) {
     if (lookupError !== null) {
@@ -23889,13 +24466,7 @@ async function openForBranch(repoRoot, branch, options, queryPullRequests, promp
   );
 }
 async function openSelectedEntry(entry, options, promptForPullRequest, openInBrowser) {
-  const numbers = entry.pullRequestNumbers ?? [];
-  const urls = entry.pullRequestUrls ?? [];
-  const pullRequests = numbers.map((number, index) => ({
-    number,
-    sourceBranch: entry.branch ?? "",
-    url: urls[index] ?? ""
-  })).filter((pullRequest) => pullRequest.url.length > 0);
+  const pullRequests = entry.pullRequests ?? [];
   return openPullRequests(
     pullRequests,
     options,
@@ -23962,7 +24533,7 @@ function formatError(error) {
 }
 
 // src/remove.ts
-import { basename as basename10 } from "node:path";
+import { basename as basename11 } from "node:path";
 var REMOVE_OUTPUT_FILE_ENV = "GJI_REMOVE_OUTPUT_FILE";
 function createRemoveCommand(dependencies = {}) {
   const promptForWorktree2 = dependencies.promptForWorktree ?? defaultPromptForWorktree3;
@@ -24068,7 +24639,7 @@ function createRemoveCommand(dependencies = {}) {
       {
         branch: worktree.branch ?? void 0,
         path: worktree.path,
-        repo: basename10(repository.repoRoot)
+        repo: basename11(repository.repoRoot)
       },
       options.stderr
     );
@@ -24096,6 +24667,7 @@ function createRemoveCommand(dependencies = {}) {
       }
     }
     await finalizeUndoOperation(journal, [worktree]);
+    await releaseWorktreeSlot(worktree.path);
     if (worktree.branch) {
       try {
         await deleteBranch(repository.repoRoot, worktree.branch);
@@ -24219,7 +24791,8 @@ async function runHookCommand(options) {
     {
       branch: currentWorktree?.branch ?? void 0,
       path: repository.currentRoot,
-      repo: repository.repoName
+      repo: repository.repoName,
+      slot: await getWorktreeSlot(repository.currentRoot)
     },
     options.stderr
   );
@@ -24284,12 +24857,18 @@ function formatStatusJson(repoRoot, currentRoot, rows) {
   };
 }
 async function buildStatusRow(worktree) {
-  const health = await readWorktreeHealth(worktree.path);
+  const [health, slot, task] = await Promise.all([
+    readWorktreeHealth(worktree.path),
+    getWorktreeSlot(worktree.path),
+    readTask(worktree.path)
+  ]);
   return {
     branch: worktree.branch,
     current: worktree.isCurrent,
     path: worktree.path,
+    slot,
     status: health.status,
+    task: task?.task ?? null,
     upstream: buildUpstreamState2(worktree.branch, health)
   };
 }
@@ -24458,11 +25037,11 @@ function resolveConfiguredString2(value) {
 }
 
 // src/sync-files-command.ts
-import { homedir as homedir9 } from "node:os";
-import { join as join16 } from "node:path";
+import { homedir as homedir10 } from "node:os";
+import { join as join18 } from "node:path";
 async function runSyncFilesCommand(options) {
   const repository = await detectRepository(options.cwd);
-  const home = options.home ?? homedir9();
+  const home = options.home ?? homedir10();
   const loaded = await loadGlobalConfig(home);
   const repoEntry = findRepoConfigEntry(
     loaded.config,
@@ -24594,10 +25173,40 @@ function writeError(options, message) {
 }
 function expandTilde3(value, home) {
   if (value === "~") return home;
-  if (value.startsWith("~/")) return join16(home, value.slice(2));
+  if (value.startsWith("~/")) return join18(home, value.slice(2));
   return value;
 }
 
+// src/task-command.ts
+async function runTaskCommand(options) {
+  const repository = await detectRepository(options.cwd);
+  if (options.clear && options.task !== void 0)
+    return emitTaskError(options, "--clear cannot be combined with a task");
+  if (options.clear) await clearTask(repository.currentRoot);
+  else if (options.task !== void 0)
+    await writeTask(repository.currentRoot, options.task);
+  const task = await readTask(repository.currentRoot);
+  if (options.json) {
+    options.stdout(
+      `${JSON.stringify({ task: task?.task ?? null }, null, 2)}
+`
+    );
+  } else if (task) {
+    options.stdout(`${task.task}
+`);
+  } else {
+    options.stdout('no task set \u2014 set one: gji task "..."\n');
+  }
+  return 0;
+}
+function emitTaskError(options, message) {
+  if (options.json) options.stderr(`${JSON.stringify({ error: message })}
+`);
+  else options.stderr(`gji task: ${message}
+`);
+  return 1;
+}
+
 // src/warp.ts
 var WARP_OUTPUT_FILE_ENV = "GJI_WARP_OUTPUT_FILE";
 async function runWarpCommand(options) {
@@ -24746,7 +25355,7 @@ async function runCli(argv, options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const stdout2 = options.stdout ?? (() => void 0);
   const stderr = options.stderr ?? (() => void 0);
-  if (shouldRegisterCurrentRepo(argv)) {
+  if (shouldRegisterCurrentRepo(argv) || isHubInvocation(argv)) {
     await maybeRegisterCurrentRepo(cwd);
   }
   const program2 = createProgram();
@@ -24755,9 +25364,19 @@ async function runCli(argv, options = {}) {
     writeOut: stdout2
   });
   program2.exitOverride();
-  if (argv.length === 0) {
-    program2.outputHelp();
-    return { exitCode: 0 };
+  if (isHubInvocation(argv)) {
+    const exitCode = await runHubCommand(
+      {
+        columns: options.columns,
+        cwd,
+        json: argv.includes("--json"),
+        now: options.now,
+        stderr,
+        stdout: stdout2
+      },
+      options.hubDependencies
+    );
+    return { exitCode };
   }
   try {
     attachCommandActions(program2, {
@@ -24808,6 +25427,9 @@ function shouldRegisterCurrentRepo(argv) {
     "init"
   ].includes(command ?? "");
 }
+function isHubInvocation(argv) {
+  return argv.length === 0 || argv.length === 1 && argv[0] === "--json";
+}
 async function maybeRegisterCurrentRepo(cwd) {
   try {
     const { repoRoot } = await detectRepository(cwd);
@@ -24827,7 +25449,7 @@ function registerCommands(program2) {
   ).option(
     "--no-fetch",
     "skip refreshing the remote default branch before creating the new branch"
-  ).option("--take", "move current uncommitted changes into the new worktree").option(
+  ).option("--take", "move current uncommitted changes into the new worktree").option("--task <description>", "record the purpose of the new worktree").option(
     "--copy",
     "copy current uncommitted changes instead of moving them (requires --take)"
   ).option("--open", "open the new worktree in an editor after creation").option(
@@ -24874,9 +25496,10 @@ function registerCommands(program2) {
     "--workspace",
     "generate a .code-workspace file before opening (VS Code / Cursor / Windsurf)"
   ).action(notImplemented("open"));
-  program2.command("go [branch]").alias("jump").description("resolve and jump to a worktree path").option("--root", "navigate to the main repository root").option("--print", "print the resolved worktree path explicitly").option("--json", "emit JSON for an existing worktree destination").action(notImplemented("go"));
+  program2.command("go [branch]").alias("jump").description("resolve and jump to a worktree path").option("--root", "navigate to the main repository root").option("--print", "print the resolved worktree path explicitly").option("--quiet", "suppress the context card").option("--json", "emit JSON for an existing worktree destination").action(notImplemented("go"));
   program2.command("root").description("print the main repository root path").option("--print", "print the resolved repository root path explicitly").action(notImplemented("root"));
   program2.command("status").description("summarize repository and worktree health").option("--json", "print repository and worktree health as JSON").action(notImplemented("status"));
+  program2.command("task [task]").description("show or update the current worktree task").option("--clear", "clear the current worktree task").option("--json", "emit task metadata as JSON").action(notImplemented("task"));
   program2.command("sync").description("fetch and update one or all worktrees").option("--all", "sync every worktree in the repository").option(
     "--json",
     "emit JSON on success or error instead of human-readable output"
@@ -24935,7 +25558,8 @@ function attachCommandActions(program2, options) {
         noFetch: commandOptions2.fetch === false,
         json: commandOptions2.json,
         open: commandOptions2.open,
-        take: commandOptions2.take
+        take: commandOptions2.take,
+        task: commandOptions2.task
       });
       if (exitCode !== 0) {
         throw commanderExit(exitCode);
@@ -25094,6 +25718,7 @@ function attachCommandActions(program2, options) {
         cwd: options.cwd,
         json: commandOptions2.json,
         print: commandOptions2.print,
+        quiet: commandOptions2.quiet,
         root: commandOptions2.root,
         stderr: options.stderr,
         stdout: options.stdout
@@ -25123,6 +25748,19 @@ function attachCommandActions(program2, options) {
       throw commanderExit(exitCode);
     }
   });
+  program2.commands.find((command) => command.name() === "task")?.action(
+    async (task, commandOptions2) => {
+      const exitCode = await runTaskCommand({
+        clear: commandOptions2.clear,
+        cwd: options.cwd,
+        json: commandOptions2.json,
+        stderr: options.stderr,
+        task,
+        stdout: options.stdout
+      });
+      if (exitCode !== 0) throw commanderExit(exitCode);
+    }
+  );
   program2.commands.find((command) => command.name() === "sync")?.action(async (commandOptions2) => {
     const exitCode = await runSyncCommand({
       all: commandOptions2.all,
@@ -25354,7 +25992,7 @@ async function main() {
 }
 async function warnIfMissingShellIntegration() {
   try {
-    const { config } = await loadGlobalConfig(homedir10());
+    const { config } = await loadGlobalConfig(homedir11());
     if (!config.shellIntegration) {
       const setupCommand = isHeadless() ? legacyShellSetupCommand() : "gji init";
       process.stderr.write(