techunter 0.1.10 → 1.0.0

package/dist/mcp.js

@@ -39,12 +39,20 @@ __export(github_exports, {
   createTask: () => createTask,
   editTask: () => editTask,
   embedBaseCommit: () => embedBaseCommit,
+  embedTargetBranch: () => embedTargetBranch,
   ensureLabels: () => ensureLabels,
+  ensureRemoteBranch: () => ensureRemoteBranch,
   extractBaseCommit: () => extractBaseCommit,
+  extractTargetBranch: () => extractTargetBranch,
   formatGuideAsMarkdown: () => formatGuideAsMarkdown,
   getAuthenticatedUser: () => getAuthenticatedUser,
   getDefaultBranch: () => getDefaultBranch,
+  getIssueNumberFromBranch: () => getIssueNumberFromBranch,
+  getOpenSubtasks: () => getOpenSubtasks,
+  getRepoFile: () => getRepoFile,
   getTask: () => getTask,
+  getTaskPR: () => getTaskPR,
+  getTaskPRDiff: () => getTaskPRDiff,
   isCollaborator: () => isCollaborator,
   listComments: () => listComments,
   listMyTasks: () => listMyTasks,
@@ -54,7 +62,8 @@ __export(github_exports, {
   mergeWorkerIntoBase: () => mergeWorkerIntoBase,
   postComment: () => postComment,
   postGuideComment: () => postGuideComment,
-  rejectTask: () => rejectTask
+  rejectTask: () => rejectTask,
+  upsertRepoFile: () => upsertRepoFile
 });
 import { Octokit } from "@octokit/rest";
 import { fetch as undiciFetch } from "undici";
@@ -117,11 +126,22 @@ function extractBaseCommit(body) {
   const match = body.match(/<!-- techunter-base:([a-f0-9]{7,40}) -->/);
   return match?.[1] ?? null;
 }
-async function createTask(config, title, body, baseCommit) {
+function embedTargetBranch(body, branch) {
+  return `${body}
+${TARGET_BRANCH_MARKER}${branch} -->`;
+}
+function extractTargetBranch(body) {
+  if (!body) return null;
+  const match = body.match(/<!-- techunter-target:([^\s>]+) -->/);
+  return match?.[1] ?? null;
+}
+async function createTask(config, title, body, baseCommit, targetBranch) {
   const octokit = createOctokit(config.githubToken);
   const { owner, repo } = config.github;
   await ensureLabels(config);
-  const finalBody = baseCommit ? embedBaseCommit(body ?? "", baseCommit) : body;
+  let finalBody = body ?? "";
+  if (baseCommit) finalBody = embedBaseCommit(finalBody, baseCommit);
+  if (targetBranch) finalBody = embedTargetBranch(finalBody, targetBranch);
   const { data } = await octokit.issues.create({
     owner,
     repo,
@@ -134,13 +154,22 @@ async function createTask(config, title, body, baseCommit) {
 async function mergeWorkerIntoBase(config, workerBranch, baseBranch) {
   const octokit = createOctokit(config.githubToken);
   const { owner, repo } = config.github;
-  await octokit.repos.merge({
-    owner,
-    repo,
-    base: baseBranch,
-    head: workerBranch,
-    commit_message: `chore: merge ${workerBranch} into ${baseBranch}`
-  });
+  try {
+    await octokit.repos.merge({
+      owner,
+      repo,
+      base: baseBranch,
+      head: workerBranch,
+      commit_message: `chore: merge ${workerBranch} into ${baseBranch}`
+    });
+  } catch (err) {
+    if (err.status === 409) {
+      throw new Error(
+        `Merge conflict: ${workerBranch} cannot be merged into ${baseBranch} cleanly. Resolve conflicts manually.`
+      );
+    }
+    throw err;
+  }
 }
 async function claimTask(config, number, username) {
   const octokit = createOctokit(config.githubToken);
@@ -216,6 +245,23 @@ async function postGuideComment(config, number, guide) {
     body
   });
 }
+async function ensureRemoteBranch(config, branchName, fallbackBase) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  try {
+    await octokit.repos.getBranch({ owner, repo, branch: branchName });
+    return;
+  } catch (err) {
+    if (err.status !== 404) throw err;
+  }
+  const { data: baseRef } = await octokit.repos.getBranch({ owner, repo, branch: fallbackBase });
+  await octokit.git.createRef({
+    owner,
+    repo,
+    ref: `refs/heads/${branchName}`,
+    sha: baseRef.commit.sha
+  });
+}
 async function createPR(config, title, body, branch, base) {
   const octokit = createOctokit(config.githubToken);
   const { owner, repo } = config.github;
@@ -232,14 +278,11 @@ async function createPR(config, title, body, branch, base) {
 async function markInReview(config, number) {
   const octokit = createOctokit(config.githubToken);
   const { owner, repo } = config.github;
-  try {
-    await octokit.issues.removeLabel({
-      owner,
-      repo,
-      issue_number: number,
-      name: LABEL_CLAIMED
-    });
-  } catch {
+  for (const label of [LABEL_CLAIMED, LABEL_CHANGES_NEEDED]) {
+    try {
+      await octokit.issues.removeLabel({ owner, repo, issue_number: number, name: label });
+    } catch {
+    }
   }
   await octokit.issues.addLabels({
     owner,
@@ -354,28 +397,115 @@ async function editTask(config, number, title, body) {
   const { owner, repo } = config.github;
   await octokit.issues.update({ owner, repo, issue_number: number, title, body });
 }
+async function upsertRepoFile(config, filePath, content, message) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  let sha;
+  try {
+    const { data: data2 } = await octokit.repos.getContent({ owner, repo, path: filePath });
+    if (!Array.isArray(data2) && data2.type === "file") {
+      sha = data2.sha;
+    }
+  } catch {
+  }
+  const { data } = await octokit.repos.createOrUpdateFileContents({
+    owner,
+    repo,
+    path: filePath,
+    message,
+    content: Buffer.from(content, "utf-8").toString("base64"),
+    ...sha ? { sha } : {}
+  });
+  return data.content?.html_url ?? `https://github.com/${owner}/${repo}/blob/main/${filePath}`;
+}
+async function getRepoFile(config, filePath) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  try {
+    const { data } = await octokit.repos.getContent({ owner, repo, path: filePath });
+    if (!Array.isArray(data) && data.type === "file" && "content" in data) {
+      return Buffer.from(data.content, "base64").toString("utf-8");
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 async function getDefaultBranch(config) {
   const octokit = createOctokit(config.githubToken);
   const { owner, repo } = config.github;
   const { data } = await octokit.repos.get({ owner, repo });
   return data.default_branch;
 }
-async function acceptTask(config, issueNumber, headBranch) {
+async function getTaskPR(config, issueNumber) {
   const octokit = createOctokit(config.githubToken);
   const { owner, repo } = config.github;
   const { data: prs } = await octokit.pulls.list({ owner, repo, state: "open", per_page: 100 });
-  const pr = headBranch ? prs.find((p) => p.head.ref === headBranch) : prs.find((p) => p.head.ref.startsWith(`task-${issueNumber}-`) || p.head.ref.startsWith("worker-"));
-  if (!pr) throw new Error(`No open PR found for task #${issueNumber}`);
-  const { data: merge } = await octokit.pulls.merge({
+  const pr = prs.find(
+    (p) => new RegExp(`Closes #${issueNumber}\\b`, "i").test(p.body ?? "")
+  );
+  if (!pr) return null;
+  return { number: pr.number, url: pr.html_url, body: pr.body ?? "", baseBranch: pr.base.ref };
+}
+async function getOpenSubtasks(config, targetBranch) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  const { data } = await octokit.issues.listForRepo({
+    owner,
+    repo,
+    state: "open",
+    per_page: 100
+  });
+  return data.filter((issue) => !issue.pull_request).filter((issue) => extractTargetBranch(issue.body ?? null) === targetBranch).map((issue) => issue.number);
+}
+async function getIssueNumberFromBranch(config, branch) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  const { data: prs } = await octokit.pulls.list({ owner, repo, state: "open", per_page: 100 });
+  const pr = prs.find((p) => p.head.ref === branch);
+  if (!pr) return null;
+  const match = (pr.body ?? "").match(/Closes #(\d+)/i);
+  if (!match) return null;
+  return { issueNumber: parseInt(match[1], 10), prUrl: pr.html_url };
+}
+async function getTaskPRDiff(config, prNumber) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  const response = await octokit.pulls.get({
     owner,
     repo,
-    pull_number: pr.number,
-    merge_method: "merge"
+    pull_number: prNumber,
+    mediaType: { format: "diff" }
   });
-  await closeTask(config, issueNumber);
-  return { prNumber: pr.number, prUrl: pr.html_url, sha: merge.sha ?? "" };
+  return response.data;
+}
+async function acceptTask(config, issueNumber) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  const { data: prs } = await octokit.pulls.list({ owner, repo, state: "open", per_page: 100 });
+  const pr = prs.find(
+    (p) => new RegExp(`Closes #${issueNumber}\\b`, "i").test(p.body ?? "")
+  );
+  if (!pr) throw new Error(`No open PR found for task #${issueNumber}`);
+  try {
+    const { data: merge } = await octokit.pulls.merge({
+      owner,
+      repo,
+      pull_number: pr.number,
+      merge_method: "merge"
+    });
+    await closeTask(config, issueNumber);
+    return { prNumber: pr.number, prUrl: pr.html_url, sha: merge.sha ?? "", baseBranch: pr.base.ref };
+  } catch (err) {
+    if (err.status === 405) {
+      throw new Error(
+        `PR #${pr.number} cannot be merged \u2014 may have conflicts or is not in a mergeable state.`
+      );
+    }
+    throw err;
+  }
 }
-var LABEL_AVAILABLE, LABEL_CLAIMED, LABEL_IN_REVIEW, LABEL_CHANGES_NEEDED, LABELS, TECHUNTER_LABELS, BASE_COMMIT_MARKER;
+var LABEL_AVAILABLE, LABEL_CLAIMED, LABEL_IN_REVIEW, LABEL_CHANGES_NEEDED, LABELS, TECHUNTER_LABELS, BASE_COMMIT_MARKER, TARGET_BRANCH_MARKER;
 var init_github = __esm({
   "src/lib/github.ts"() {
     "use strict";
@@ -392,6 +522,7 @@ var init_github = __esm({
     ];
     TECHUNTER_LABELS = /* @__PURE__ */ new Set([LABEL_AVAILABLE, LABEL_CLAIMED, LABEL_IN_REVIEW, LABEL_CHANGES_NEEDED]);
     BASE_COMMIT_MARKER = "<!-- techunter-base:";
+    TARGET_BRANCH_MARKER = "<!-- techunter-target:";
   }
 });
 
@@ -428,6 +559,17 @@ function makeWorkerBranchName(username) {
   const slug = username.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "user";
   return `worker-${slug}`;
 }
+function makeTaskBranchName(issueNumber, username) {
+  const slug = username.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "user";
+  return `task-${issueNumber}-${slug}`;
+}
+function isTaskBranch(branch) {
+  return /^task-\d+-/.test(branch);
+}
+function parseIssueNumberFromBranch(branch) {
+  const match = branch.match(/^task-(\d+)-/);
+  return match ? parseInt(match[1], 10) : null;
+}
 async function getCurrentCommit() {
   return (await git.revparse(["HEAD"])).trim();
 }
@@ -548,16 +690,27 @@ async function getRemoteHeadSha(baseBranch) {
   await git.fetch("origin", baseBranch);
   return (await git.revparse([`origin/${baseBranch}`])).trim();
 }
-async function resetOrCreateBranch(branchName, sha) {
-  const branches = await git.branch();
-  const localExists = Object.keys(branches.branches).some((b) => b === branchName);
-  if (localExists) {
+async function checkoutFromCommit(branchName, sha) {
+  const branches = await git.branch(["-a"]);
+  const exists = Object.keys(branches.branches).some(
+    (b) => b === branchName || b === `remotes/origin/${branchName}`
+  );
+  if (exists) {
     await git.checkout(branchName);
-    await git.reset(["--hard", sha]);
   } else {
     await git.checkoutBranch(branchName, sha);
   }
 }
+async function hasUncommittedChanges() {
+  const status = await git.status();
+  return !status.isClean();
+}
+async function stash(message) {
+  await git.stash(["push", "-u", "-m", message]);
+}
+async function stashPop() {
+  await git.stash(["pop"]);
+}
 
 // src/tools/pick/index.ts
 init_github();
@@ -578,7 +731,8 @@ var configSchema = z.object({
   }),
   taskState: z.object({
     activeIssueNumber: z.number().optional(),
-    baseCommit: z.string().optional()
+    baseCommit: z.string().optional(),
+    activeBranch: z.string().optional()
   }).optional()
 });
 var store = new Conf({
@@ -665,11 +819,22 @@ function colorStatus(status) {
       return padded;
   }
 }
+function parentIssueFromBranch(branch) {
+  if (!isTaskBranch(branch)) return null;
+  const match = branch.match(/^task-(\d+)-/);
+  return match ? parseInt(match[1], 10) : null;
+}
+function getParentIssueNumber(issue) {
+  const target = extractTargetBranch(issue.body);
+  if (!target) return null;
+  return parentIssueFromBranch(target);
+}
 function printTaskDetail(issue) {
   const divider = chalk2.dim("\u2500".repeat(70));
+  const parentNum = getParentIssueNumber(issue);
   console.log("\n" + divider);
   console.log(
-    chalk2.bold(` #${issue.number}`) + "  " + colorStatus(getStatus(issue)) + "  " + chalk2.dim(issue.assignee ? `@${issue.assignee}` : "\u2014")
+    chalk2.bold(` #${issue.number}`) + "  " + colorStatus(getStatus(issue)) + "  " + chalk2.dim(issue.assignee ? `@${issue.assignee}` : "\u2014") + (parentNum ? chalk2.dim(`  sub-task of #${parentNum}`) : "")
   );
   console.log(chalk2.bold("\n " + issue.title));
   if (issue.body) {
@@ -689,12 +854,34 @@ async function printTaskList(config) {
     if (tasks.length === 0) {
       console.log(chalk2.dim("  (no tasks)"));
     } else {
-      for (const t of tasks) {
+      let printTask2 = function(t, indent, connector, isLast) {
         const num = `#${t.number}`.padEnd(5);
         const status = colorStatus(getStatus(t));
         const assignee = (t.assignee ? `@${t.assignee}` : "\u2014").padEnd(16);
-        const title = t.title.length > 36 ? t.title.slice(0, 33) + "..." : t.title;
-        console.log(` ${num}${status}${assignee}${title}`);
+        const fullPrefix = indent + connector;
+        const maxTitle = 36 - fullPrefix.length;
+        const title = t.title.length > maxTitle ? t.title.slice(0, maxTitle - 3) + "..." : t.title;
+        console.log(` ${num}${status}${assignee}${chalk2.dim(fullPrefix)}${title}`);
+        const children = childrenOf.get(t.number) ?? [];
+        const childIndent = indent + (isLast ? "   " : "\u2502  ");
+        for (let i = 0; i < children.length; i++) {
+          const childIsLast = i === children.length - 1;
+          printTask2(children[i], childIndent, childIsLast ? "\u2514\u2500 " : "\u251C\u2500 ", childIsLast);
+        }
+      };
+      var printTask = printTask2;
+      const taskMap = new Map(tasks.map((t) => [t.number, t]));
+      const childrenOf = /* @__PURE__ */ new Map();
+      for (const t of tasks) {
+        const parentNum = getParentIssueNumber(t);
+        const key = parentNum !== null && taskMap.has(parentNum) ? parentNum : null;
+        if (!childrenOf.has(key)) childrenOf.set(key, []);
+        childrenOf.get(key).push(t);
+      }
+      const roots = childrenOf.get(null) ?? [];
+      for (let i = 0; i < roots.length; i++) {
+        const isLast = i === roots.length - 1;
+        printTask2(roots[i], "", isLast ? "\u2514\u2500 " : "\u251C\u2500 ", isLast);
       }
     }
     console.log(divider);
@@ -852,7 +1039,7 @@ ${issue.body ?? "(none)"}
 
 Diff:
 ${diff || "(no changes)"}`,
-    ["run_command", "read_file", "get_diff"]
+    ["run_command", "grep_code", "get_diff"]
   );
 }
 
@@ -873,9 +1060,19 @@ var definition = {
 };
 async function run(_input, config) {
   const taskState = getConfig().taskState;
-  const issueNumber = taskState?.activeIssueNumber;
+  const currentBranch = await getCurrentBranch();
+  let issueNumber = taskState?.activeIssueNumber && taskState?.activeBranch && currentBranch === taskState.activeBranch ? taskState.activeIssueNumber : void 0;
   if (!issueNumber) {
-    return "No active task found. Claim a task first with /pick.";
+    const fromBranch = parseIssueNumberFromBranch(currentBranch);
+    if (fromBranch) {
+      issueNumber = fromBranch;
+    } else {
+      const found = await getIssueNumberFromBranch(config, currentBranch);
+      if (!found) {
+        return "No active task found. Claim a task first with /pick.";
+      }
+      issueNumber = found.issueNumber;
+    }
   }
   let spinner = ora("Loading task and diff\u2026").start();
   const diffPromise = taskState?.baseCommit ? getDiffFromCommit(taskState.baseCommit) : getDiff();
@@ -885,9 +1082,16 @@ async function run(_input, config) {
     getAuthenticatedUser(config)
   ]);
   spinner.stop();
-  const workerBranch = makeWorkerBranchName(issue.author ?? me);
+  const targetBranch = extractTargetBranch(issue.body) ?? makeWorkerBranchName(issue.author ?? me);
   const branch = await getCurrentBranch();
   const isSelfSubmit = issue.author !== null && issue.author === me;
+  spinner = ora("Checking for open sub-tasks\u2026").start();
+  const openSubtaskNumbers = await getOpenSubtasks(config, branch);
+  spinner.stop();
+  if (openSubtaskNumbers.length > 0) {
+    return `Cannot submit: ${openSubtaskNumbers.length} sub-task(s) still open:
+` + openSubtaskNumbers.map((n) => `  - #${n}`).join("\n") + "\nComplete all sub-tasks before submitting.";
+  }
   let review = "";
   if (!isSelfSubmit) {
     const reviewSpinner = ora("Reviewing changes\u2026").start();
@@ -948,26 +1152,35 @@ async function run(_input, config) {
       spinner.stop();
       console.error(chalk5.yellow(`Warning: failed to close issue: ${err.message}`));
     }
-    setConfig({ taskState: { activeIssueNumber: void 0, baseCommit: void 0 } });
+    setConfig({ taskState: { activeIssueNumber: void 0, baseCommit: void 0, activeBranch: void 0 } });
     return `Task #${issueNumber} committed and closed.
 Commit: "${commitMessage.trim()}"`;
   }
-  spinner = ora("Creating pull request\u2026").start();
+  spinner = ora("Checking for existing PR\u2026").start();
+  const existingPR = await getTaskPR(config, issueNumber);
+  spinner.stop();
   let prUrl;
-  try {
-    const prBody = [
-      `Closes #${issueNumber}`,
-      issue.body ? `
+  if (existingPR) {
+    prUrl = existingPR.url;
+    console.log(chalk5.dim(`  Existing PR found: ${prUrl} \u2014 updating.`));
+  } else {
+    spinner = ora("Creating pull request\u2026").start();
+    try {
+      await ensureRemoteBranch(config, targetBranch, config.baseBranch ?? "main");
+      const prBody = [
+        `Closes #${issueNumber}`,
+        issue.body ? `
 ${issue.body}` : "",
-      review ? `
+        review ? `
 ## AI Review
 ${review}` : ""
-    ].join("\n").trim();
-    prUrl = await createPR(config, issue.title, prBody, branch, workerBranch);
-    spinner.stop();
-  } catch (err) {
-    spinner.stop();
-    return `Committed but PR creation failed: ${err.message}`;
+      ].join("\n").trim();
+      prUrl = await createPR(config, issue.title, prBody, branch, targetBranch);
+      spinner.stop();
+    } catch (err) {
+      spinner.stop();
+      return `Committed but PR creation failed: ${err.message}`;
+    }
   }
   spinner = ora("Marking as in-review\u2026").start();
   try {
@@ -975,17 +1188,27 @@ ${review}` : ""
     spinner.stop();
   } catch (err) {
     spinner.stop();
-    return `PR created (${prUrl}) but failed to update label: ${err.message}`;
+    return `PR ${existingPR ? "updated" : "created"} (${prUrl}) but failed to update label: ${err.message}`;
   }
-  setConfig({ taskState: { activeIssueNumber: void 0, baseCommit: void 0 } });
-  return `Task #${issueNumber} submitted.
+  setConfig({ taskState: { activeIssueNumber: void 0, baseCommit: void 0, activeBranch: void 0 } });
+  return `Task #${issueNumber} ${existingPR ? "re-submitted" : "submitted"}.
 Commit: "${commitMessage.trim()}"
 PR: ${prUrl}`;
 }
 async function execute(input, config) {
   const taskState = getConfig().taskState;
-  const issueNumber = taskState?.activeIssueNumber;
-  if (!issueNumber) return "No active task found. Claim a task first.";
+  let issueNumber = taskState?.activeIssueNumber;
+  if (!issueNumber) {
+    const currentBranch = await getCurrentBranch();
+    const fromBranch = parseIssueNumberFromBranch(currentBranch);
+    if (fromBranch) {
+      issueNumber = fromBranch;
+    } else {
+      const found = await getIssueNumberFromBranch(config, currentBranch);
+      if (!found) return "No active task found. Claim a task first.";
+      issueNumber = found.issueNumber;
+    }
+  }
   const diffPromise = taskState?.baseCommit ? getDiffFromCommit(taskState.baseCommit) : getDiff();
   const [issue, diff, branch, me] = await Promise.all([
     getTask(config, issueNumber),
@@ -993,7 +1216,11 @@ async function execute(input, config) {
     getCurrentBranch(),
     getAuthenticatedUser(config)
   ]);
-  const workerBranch = makeWorkerBranchName(issue.author ?? me);
+  const targetBranch = extractTargetBranch(issue.body) ?? makeWorkerBranchName(issue.author ?? me);
+  const openSubtaskNumbers = await getOpenSubtasks(config, branch);
+  if (openSubtaskNumbers.length > 0) {
+    return `Cannot submit: ${openSubtaskNumbers.length} sub-task(s) still open: ` + openSubtaskNumbers.map((n) => `#${n}`).join(", ");
+  }
   const isSelfSubmit = issue.author !== null && issue.author === me;
   let review = "";
   if (!isSelfSubmit) {
@@ -1014,29 +1241,36 @@ async function execute(input, config) {
       await closeTask(config, issueNumber);
     } catch {
     }
-    setConfig({ taskState: { activeIssueNumber: void 0, baseCommit: void 0 } });
+    setConfig({ taskState: { activeIssueNumber: void 0, baseCommit: void 0, activeBranch: void 0 } });
     return `Task #${issueNumber} committed and closed.
 Commit: "${commitMessage}"`;
   }
+  const existingPR = await getTaskPR(config, issueNumber);
   let prUrl;
-  try {
-    const prBody = [
-      `Closes #${issueNumber}`,
-      issue.body ? `
+  if (existingPR) {
+    prUrl = existingPR.url;
+  } else {
+    try {
+      await ensureRemoteBranch(config, targetBranch, config.baseBranch ?? "main");
+      const prBody = [
+        `Closes #${issueNumber}`,
+        issue.body ? `
 ${issue.body}` : "",
-      review ? `
+        review ? `
 ## AI Review
 ${review}` : ""
-    ].join("\n").trim();
-    prUrl = await createPR(config, issue.title, prBody, branch, workerBranch);
-  } catch (err) {
-    return `Committed but PR creation failed: ${err.message}`;
+      ].join("\n").trim();
+      prUrl = await createPR(config, issue.title, prBody, branch, targetBranch);
+    } catch (err) {
+      return `Committed but PR creation failed: ${err.message}`;
+    }
   }
   try {
     await markInReview(config, issueNumber);
   } catch {
   }
-  return `Task #${issueNumber} submitted.
+  setConfig({ taskState: { activeIssueNumber: void 0, baseCommit: void 0, activeBranch: void 0 } });
+  return `Task #${issueNumber} ${existingPR ? "re-submitted" : "submitted"}.
 Review:
 ${review}
 Commit: "${commitMessage}"
@@ -1195,8 +1429,23 @@ async function run3(input, config) {
     }
   }
   const actions = [];
-  if (status === "available") actions.push({ name: "Claim this task", value: "claim" });
-  if (status === "claimed" || status === "changes-needed") actions.push({ name: "Submit this task", value: "submit" });
+  if (status === "available") {
+    actions.push({ name: "Claim this task", value: "claim" });
+  }
+  if (status === "claimed") {
+    actions.push({ name: "Submit this task", value: "submit" });
+  }
+  if (status === "changes-needed") {
+    const { getAuthenticatedUser: getAuthenticatedUser2 } = await Promise.resolve().then(() => (init_github(), github_exports));
+    const me = await getAuthenticatedUser2(config);
+    const taskBranch = issue.assignee ? makeTaskBranchName(issue.number, issue.assignee) : makeTaskBranchName(issue.number, me);
+    const currentBranch = await getCurrentBranch();
+    if (currentBranch === taskBranch) {
+      actions.push({ name: "Submit this task (fixes done)", value: "submit" });
+    } else {
+      actions.push({ name: `Switch to ${taskBranch} to fix`, value: "switch-fix" });
+    }
+  }
   actions.push({ name: "Close this task", value: "close" });
   actions.push({ name: "Nothing, just viewing", value: "none" });
   let action;
@@ -1208,9 +1457,8 @@ async function run3(input, config) {
   if (action === "none") return `Viewed task #${issue.number}.`;
   if (action === "claim") {
     try {
-      const { getAuthenticatedUser: getAuthenticatedUser2, listMyTasks: listMyTasks2 } = await Promise.resolve().then(() => (init_github(), github_exports));
-      const me = await getAuthenticatedUser2(config);
-      const myTasks = await listMyTasks2(config, me);
+      const me = await getAuthenticatedUser(config);
+      const myTasks = await listMyTasks(config, me);
       const activeTask = myTasks.find((t) => {
         const labels = t.labels;
         return labels.includes("techunter:claimed") || labels.includes("techunter:changes-needed");
@@ -1219,33 +1467,61 @@ async function run3(input, config) {
         return `You already have an active task: #${activeTask.number} "${activeTask.title}"
 Finish or submit it before claiming a new one.`;
       }
+      let stashed = false;
+      if (await hasUncommittedChanges()) {
+        let choice;
+        try {
+          choice = await select3({
+            message: "You have uncommitted changes. What would you like to do?",
+            choices: [
+              { name: "Stash changes and switch branch (restore with: git stash pop)", value: "stash" },
+              { name: "Cancel", value: "cancel" }
+            ]
+          });
+        } catch {
+          choice = "cancel";
+        }
+        if (choice === "cancel") return "Cancelled.";
+        await stash(`tch: before claiming #${issue.number}`);
+        stashed = true;
+        console.log(chalk6.dim("  Changes stashed. Run `git stash pop` after you finish this task to restore them."));
+      }
       let spinner = ora3(`Claiming #${issue.number}\u2026`).start();
       await claimTask(config, issue.number, me);
       spinner.stop();
-      const workerBranch = makeWorkerBranchName(me);
+      const taskBranch = makeTaskBranchName(issue.number, me);
       const taskBase = extractBaseCommit(issue.body);
-      spinner = ora3(`Switching to ${workerBranch}${taskBase ? ` from ${taskBase.slice(0, 7)}` : ""}\u2026`).start();
+      spinner = ora3(`Creating branch ${taskBranch}${taskBase ? ` from ${taskBase.slice(0, 7)}` : ""}\u2026`).start();
       try {
         if (taskBase) {
-          await resetOrCreateBranch(workerBranch, taskBase);
+          await checkoutFromCommit(taskBranch, taskBase);
         } else {
-          await switchToBranchOrCreate(workerBranch);
+          await switchToBranchOrCreate(taskBranch);
         }
         spinner.stop();
-        spinner = ora3("Pushing worker branch\u2026").start();
+        spinner = ora3("Pushing task branch\u2026").start();
         try {
-          await pushBranch(workerBranch);
+          await pushBranch(taskBranch);
           spinner.stop();
         } catch {
-          spinner.warn("Could not push worker branch");
+          spinner.warn("Could not push task branch \u2014 will push on submit");
         }
-      } catch {
-        spinner.warn(`Could not switch to ${workerBranch}`);
+      } catch (err) {
+        spinner.warn(`Could not switch to ${taskBranch}`);
+        if (stashed) {
+          try {
+            await stashPop();
+            console.log(chalk6.dim("  Restored stashed changes."));
+          } catch {
+            console.log(chalk6.yellow("  Warning: could not restore stash automatically. Run `git stash pop` manually."));
+          }
+        }
+        throw err;
       }
       const baseCommit = await getCurrentCommit();
-      setConfig({ taskState: { activeIssueNumber: issue.number, baseCommit } });
+      setConfig({ taskState: { activeIssueNumber: issue.number, baseCommit, activeBranch: taskBranch } });
       console.log(chalk6.green(`
-  Claimed! Branch: ${workerBranch}  (base: ${baseCommit.slice(0, 7)})
+  Claimed! Branch: ${taskBranch}  (base: ${baseCommit.slice(0, 7)})
 `));
       let openClaude;
       try {
@@ -1259,12 +1535,58 @@ Finish or submit it before claiming a new one.`;
       } catch {
         openClaude = false;
       }
-      if (openClaude) await launchClaudeCode(issue, workerBranch);
-      return `Task #${issue.number} claimed. Branch: ${workerBranch}`;
+      if (openClaude) await launchClaudeCode(issue, taskBranch);
+      return `Task #${issue.number} claimed. Branch: ${taskBranch}`;
     } catch (err) {
       return `Error claiming task: ${err.message}`;
     }
   }
+  if (action === "switch-fix") {
+    const { getAuthenticatedUser: getAuthenticatedUser2 } = await Promise.resolve().then(() => (init_github(), github_exports));
+    const me = await getAuthenticatedUser2(config);
+    const taskBranch = issue.assignee ? makeTaskBranchName(issue.number, issue.assignee) : makeTaskBranchName(issue.number, me);
+    let stashed = false;
+    if (await hasUncommittedChanges()) {
+      let choice;
+      try {
+        choice = await select3({
+          message: "You have uncommitted changes. What would you like to do?",
+          choices: [
+            { name: "Stash changes and switch branch (restore with: git stash pop)", value: "stash" },
+            { name: "Cancel", value: "cancel" }
+          ]
+        });
+      } catch {
+        choice = "cancel";
+      }
+      if (choice === "cancel") return "Cancelled.";
+      await stash(`tch: before switching to ${taskBranch}`);
+      stashed = true;
+      console.log(chalk6.dim("  Changes stashed. Run `git stash pop` to restore them later."));
+    }
+    const spinner = ora3(`Switching to ${taskBranch}\u2026`).start();
+    try {
+      await switchToBranchOrCreate(taskBranch);
+      spinner.stop();
+    } catch (err) {
+      spinner.warn(`Could not switch to ${taskBranch}: ${err.message}`);
+      if (stashed) {
+        try {
+          await stashPop();
+          console.log(chalk6.dim("  Restored stashed changes."));
+        } catch {
+          console.log(chalk6.yellow("  Run `git stash pop` manually to restore your changes."));
+        }
+      }
+      return `Error: ${err.message}`;
+    }
+    const baseCommit = extractBaseCommit(issue.body) ?? await getCurrentCommit();
+    setConfig({ taskState: { activeIssueNumber: issue.number, baseCommit, activeBranch: taskBranch } });
+    console.log(chalk6.green(`
+  Switched to ${taskBranch}. Fix the issues then run /submit.
+`));
+    return `Switched to ${taskBranch} for task #${issue.number}.`;
+  }
   if (action === "submit") return run({}, config);
   if (action === "close") return run2({ issue_number: issue.number }, config);
   return "Cancelled.";
@@ -1293,28 +1615,31 @@ async function execute3(input, config) {
     if (activeTask) {
       return `You already have an active task: #${activeTask.number} "${activeTask.title}". Finish it before claiming a new one.`;
     }
+    if (await hasUncommittedChanges()) {
+      return "Cannot claim: you have uncommitted changes. Commit or stash them first (git stash).";
+    }
     try {
       await claimTask(config, issueNumber, me);
     } catch (err) {
       return `Error claiming task: ${err.message}`;
     }
-    const workerBranch = makeWorkerBranchName(me);
+    const taskBranch = makeTaskBranchName(issue.number, me);
     const taskBase = extractBaseCommit(issue.body);
     try {
       if (taskBase) {
-        await resetOrCreateBranch(workerBranch, taskBase);
+        await checkoutFromCommit(taskBranch, taskBase);
       } else {
-        await switchToBranchOrCreate(workerBranch);
+        await switchToBranchOrCreate(taskBranch);
       }
     } catch {
     }
     try {
-      await pushBranch(workerBranch);
+      await pushBranch(taskBranch);
     } catch {
     }
     const baseCommit = await getCurrentCommit();
-    setConfig({ taskState: { activeIssueNumber: issueNumber, baseCommit } });
-    return `Task #${issueNumber} claimed. Branch: ${workerBranch} (base commit: ${baseCommit.slice(0, 7)})`;
+    setConfig({ taskState: { activeIssueNumber: issueNumber, baseCommit, activeBranch: taskBranch } });
+    return `Task #${issueNumber} claimed. Branch: ${taskBranch} (base commit: ${baseCommit.slice(0, 7)})`;
   }
   return `Unknown action: ${action}`;
 }
@@ -1366,9 +1691,9 @@ Previous guide:
 ${revise.previousGuide}` : `Write an implementation guide for this task: "${title}"`;
   return runSubAgentLoop(
     config,
-    "You are a senior engineer writing a brief task guide for a developer. Use scan_project and read_file to identify which files are relevant. Do NOT include code snippets or implementation details. When you have enough context, write the guide.\n\n" + GUIDE_FORMAT,
+    "You are a senior engineer writing a brief task guide for a developer. Use list_files then grep_code to identify which files are relevant. Do NOT include code snippets or implementation details. When you have enough context, write the guide.\n\n" + GUIDE_FORMAT,
     userMessage,
-    ["scan_project", "read_file", "run_command", "ask_user"]
+    ["list_files", "grep_code", "run_command", "ask_user"]
   );
 }
 
@@ -1389,6 +1714,77 @@ async function openInEditor(content) {
     await rm(dir, { recursive: true, force: true });
   }
 }
+async function resolveBaseAndTarget(config, me, interactive) {
+  const currentBranch = await getCurrentBranch();
+  if (isTaskBranch(currentBranch)) {
+    if (await hasUncommittedChanges()) {
+      if (!interactive) {
+        throw new Error("Cannot create sub-task: you have uncommitted changes. Commit them first so the executor starts from the correct base.");
+      }
+      const { select: inquirerSelect } = await import("@inquirer/prompts");
+      let choice;
+      try {
+        choice = await inquirerSelect({
+          message: "You have uncommitted changes. The sub-task executor will start from the last commit \u2014 they won't see your current unsaved work.",
+          choices: [
+            { name: "Commit first (cancel and commit manually)", value: "cancel" },
+            { name: "Continue anyway (executor starts without my unsaved changes)", value: "continue" }
+          ]
+        });
+      } catch {
+        choice = "cancel";
+      }
+      if (choice === "cancel") throw new Error("Cancelled. Commit your changes first, then create the sub-task.");
+    }
+    const baseCommit2 = await getCurrentCommit();
+    return { baseCommit: baseCommit2, targetBranch: currentBranch, isSubtask: true };
+  }
+  let stashedForSync = false;
+  if (await hasUncommittedChanges()) {
+    if (!interactive) {
+      throw new Error("Cannot create task: you have uncommitted changes. Commit or stash them first (git stash).");
+    }
+    const { select: inquirerSelect } = await import("@inquirer/prompts");
+    let choice;
+    try {
+      choice = await inquirerSelect({
+        message: "You have uncommitted changes. Syncing with main requires a clean working tree.",
+        choices: [
+          { name: "Stash changes and continue (restore with: git stash pop)", value: "stash" },
+          { name: "Cancel", value: "cancel" }
+        ]
+      });
+    } catch {
+      choice = "cancel";
+    }
+    if (choice === "cancel") throw new Error("Cancelled.");
+    await stash("tch: before creating new task");
+    stashedForSync = true;
+    console.log(chalk7.dim("  Changes stashed. Run `git stash pop` after creating the task."));
+  }
+  const baseBranch = config.baseBranch ?? "main";
+  let baseCommit;
+  const syncSpinner = ora4(`Syncing with ${baseBranch}\u2026`).start();
+  try {
+    await syncWithBase(baseBranch);
+    baseCommit = await getCurrentCommit();
+    syncSpinner.succeed(`Synced with ${baseBranch} (base: ${baseCommit.slice(0, 7)})`);
+  } catch {
+    syncSpinner.warn(`Could not sync with ${baseBranch} \u2014 recording remote HEAD as base`);
+    try {
+      baseCommit = await getRemoteHeadSha(baseBranch);
+    } catch {
+    }
+    if (stashedForSync) {
+      try {
+        await stashPop();
+      } catch {
+      }
+      throw new Error(`Could not sync with ${baseBranch}. Your changes have been restored from stash.`);
+    }
+  }
+  return { baseCommit, targetBranch: makeWorkerBranchName(me), isSubtask: false };
+}
 var definition4 = {
   type: "function",
   function: {
@@ -1484,26 +1880,23 @@ async function run4(input, config) {
       console.log(chalk7.yellow(`  Revision error: ${err.message}`));
     }
   }
-  const baseBranch = config.baseBranch ?? "main";
   let baseCommit;
-  const syncSpinner = ora4(`Syncing with ${baseBranch}\u2026`).start();
+  let targetBranch;
+  let isSubtask;
   try {
-    await syncWithBase(baseBranch);
-    baseCommit = await getCurrentCommit();
-    syncSpinner.succeed(`Synced with ${baseBranch} (base: ${baseCommit.slice(0, 7)})`);
-  } catch {
-    syncSpinner.warn(`Could not sync with ${baseBranch} \u2014 recording remote HEAD as base`);
-    try {
-      baseCommit = await getRemoteHeadSha(baseBranch);
-    } catch {
-    }
+    ({ baseCommit, targetBranch, isSubtask } = await resolveBaseAndTarget(config, me, true));
+  } catch (err) {
+    return err.message;
+  }
+  if (isSubtask) {
+    console.log(chalk7.dim(`  Sub-task: will target branch ${chalk7.cyan(targetBranch)} (base: ${baseCommit?.slice(0, 7) ?? "HEAD"})`));
   }
   const createSpinner = ora4(`Creating "${title}"\u2026`).start();
   let htmlUrl;
   let issueNumber;
   let issueTitle;
   try {
-    const issue = await createTask(config, title, guide, baseCommit);
+    const issue = await createTask(config, title, guide, baseCommit, targetBranch);
     createSpinner.stop();
     htmlUrl = issue.htmlUrl;
     issueNumber = issue.number;
@@ -1540,19 +1933,9 @@ async function execute4(input, config) {
   if (feedback) {
     guide = await generateGuide(config, title, { feedback, previousGuide: guide });
   }
-  const baseBranch = config.baseBranch ?? "main";
-  let baseCommit;
-  try {
-    await syncWithBase(baseBranch);
-    baseCommit = await getCurrentCommit();
-  } catch {
-    try {
-      baseCommit = await getRemoteHeadSha(baseBranch);
-    } catch {
-    }
-  }
+  const { baseCommit, targetBranch } = await resolveBaseAndTarget(config, me, false);
   try {
-    const issue = await createTask(config, title, guide, baseCommit);
+    const issue = await createTask(config, title, guide, baseCommit, targetBranch);
     return `Created #${issue.number} "${issue.title}" \u2014 ${issue.htmlUrl}
 
 Guide:
@@ -1602,119 +1985,249 @@ var terminal5 = true;
 // src/tools/review/index.ts
 var review_exports = {};
 __export(review_exports, {
+  definition: () => definition8,
+  execute: () => execute8,
+  run: () => run8,
+  terminal: () => terminal8
+});
+init_github();
+import chalk10 from "chalk";
+import ora8 from "ora";
+import { select as select7 } from "@inquirer/prompts";
+
+// src/tools/accept/index.ts
+var accept_exports = {};
+__export(accept_exports, {
   definition: () => definition6,
   execute: () => execute6,
   run: () => run6,
   terminal: () => terminal6
 });
 init_github();
+import chalk8 from "chalk";
+import { select as select5 } from "@inquirer/prompts";
 import ora6 from "ora";
-var definition6 = {
-  type: "function",
-  function: {
-    name: "review",
-    description: "List tasks waiting for your review (submitted by others, created by you). Equivalent to /review.",
-    parameters: { type: "object", properties: {}, required: [] }
-  }
-};
-async function run6(_input, config) {
-  const spinner = ora6("Loading tasks for review\u2026").start();
-  try {
-    const me = await getAuthenticatedUser(config);
-    const tasks = await listTasksForReview(config, me);
-    spinner.stop();
-    if (tasks.length === 0) return `No tasks pending review for @${me}.`;
-    const lines = tasks.map((t) => `  #${t.number}  [in-review]  @${t.assignee ?? "\u2014"}  ${t.title}`);
-    return `Tasks pending review (created by @${me}):
-${lines.join("\n")}`;
-  } catch (err) {
-    spinner.stop();
-    return `Error: ${err.message}`;
-  }
-}
-var execute6 = run6;
-var terminal6 = true;
 
-// src/tools/refresh/index.ts
-var refresh_exports = {};
-__export(refresh_exports, {
-  definition: () => definition7,
-  execute: () => execute7,
-  run: () => run7,
-  terminal: () => terminal7
-});
-var definition7 = {
-  type: "function",
-  function: {
-    name: "refresh",
-    description: "Reload and display the full task list. Equivalent to /refresh.",
-    parameters: { type: "object", properties: {}, required: [] }
-  }
-};
-async function run7(_input, config) {
-  const tasks = await printTaskList(config);
-  if (tasks.length === 0) return "No tasks found.";
-  const lines = tasks.map((t) => {
-    const status = getStatus(t);
-    const assignee = t.assignee ? `@${t.assignee}` : "\u2014";
-    return `#${t.number}  [${status}]  ${assignee}  ${t.title}`;
-  });
-  return `Tasks (${tasks.length}):
-${lines.join("\n")}`;
+// src/tools/wiki/prompts.ts
+var WIKI_FORMAT = `
+The document you produce must be valid Markdown with these exact sections:
+
+# [Project Name]
+
+> One-sentence description of what this project does.
+
+## What Is This?
+
+2-4 paragraphs covering:
+- The problem this project solves
+- Who uses it and in what context
+- Core capabilities / key features
+
+## Quick Start
+
+Numbered steps for a brand-new developer to install, configure, and run the project for the first time.
+
+## Architecture
+
+High-level explanation of how the system is structured:
+- Key components / layers and their responsibilities
+- Request or data flow (prose or ASCII diagram)
+- Noteworthy design decisions
+
+## Key Files
+
+| File / Directory | Purpose |
+|---|---|
+| ... | ... |
+
+(List the 8-15 most important files.)
+
+## Development Workflow
+
+Common day-to-day tasks a contributor will need:
+- How to build / run locally
+- How to add a new feature (brief steps)
+- Any testing or linting commands
+
+---
+*Maintained by Techunter \u2014 run \`tch wiki\` to regenerate*
+`;
+
+// src/tools/wiki/wiki-generator.ts
+async function generateWiki(config) {
+  return runSubAgentLoop(
+    config,
+    "You are a senior engineer writing a project overview document for new team members. Use list_files to understand the project structure, then grep_code and run_command to read key files (e.g. package.json, README, entry points, config files). Be concrete and specific \u2014 reference real file names, commands, and concepts from this codebase. Avoid vague filler. When you have enough context, write the document.\n\n" + WIKI_FORMAT,
+    "Analyze this project thoroughly and produce a comprehensive TECHUNTER.md overview document for new team members.",
+    ["list_files", "grep_code", "run_command"]
+  );
 }
-var execute7 = run7;
-var terminal7 = true;
 
-// src/tools/open-code/index.ts
-var open_code_exports = {};
-__export(open_code_exports, {
-  definition: () => definition8,
-  execute: () => execute8,
-  run: () => run8,
-  terminal: () => terminal8
-});
-init_github();
-var definition8 = {
+// src/tools/accept/index.ts
+var definition6 = {
   type: "function",
   function: {
-    name: "open_code",
-    description: "Launch Claude Code for the current task branch. Equivalent to /code.",
-    parameters: { type: "object", properties: {}, required: [] }
+    name: "accept",
+    description: "Accept an in-review task: merges the PR into the target branch and closes the issue.",
+    parameters: {
+      type: "object",
+      properties: {
+        issue_number: { type: "number", description: "GitHub issue number to accept" }
+      },
+      required: ["issue_number"]
+    }
   }
 };
-async function run8(_input, config) {
-  let branch;
+async function run6(input, config) {
+  let issueNumber = input["issue_number"];
+  if (!issueNumber) {
+    const spinner3 = ora6("Loading tasks for review\u2026").start();
+    let tasks;
+    let me;
+    try {
+      me = await getAuthenticatedUser(config);
+      tasks = await listTasksForReview(config, me);
+      spinner3.stop();
+    } catch (err) {
+      spinner3.stop();
+      return `Error: ${err.message}`;
+    }
+    if (tasks.length === 0) return "No tasks pending review.";
+    try {
+      issueNumber = await select5({
+        message: "Which task to accept?",
+        choices: tasks.map((t) => ({
+          name: `#${t.number}  @${t.assignee ?? "\u2014"}  ${t.title}`,
+          value: t.number
+        }))
+      });
+    } catch {
+      return "Cancelled.";
+    }
+  }
+  const spinner2 = ora6("Verifying permissions\u2026").start();
+  let me2;
+  let issue;
   try {
-    branch = await getCurrentBranch();
+    [me2, issue] = await Promise.all([
+      getAuthenticatedUser(config),
+      getTask(config, issueNumber)
+    ]);
+    spinner2.stop();
   } catch (err) {
+    spinner2.stop();
     return `Error: ${err.message}`;
   }
-  const match = branch.match(/^task-(\d+)-/);
-  if (!match) return `Not on a task branch (current: ${branch}).`;
-  const issueNum = parseInt(match[1], 10);
-  let issue;
+  if (issue.author && issue.author !== me2) {
+    return `Permission denied: only the task author (@${issue.author}) can accept task #${issueNumber}.`;
+  }
+  let confirmed;
   try {
-    issue = await getTask(config, issueNum);
+    confirmed = await select5({
+      message: `Merge PR for #${issueNumber} and close issue?`,
+      choices: [
+        { name: "Yes, accept", value: true },
+        { name: "Cancel", value: false }
+      ]
+    });
+  } catch {
+    return "Cancelled.";
+  }
+  if (!confirmed) return "Cancelled.";
+  const spinner = ora6(`Merging PR for #${issueNumber}\u2026`).start();
+  let result;
+  try {
+    result = await acceptTask(config, issueNumber);
+    spinner.succeed(`PR #${result.prNumber} merged \u2192 ${chalk8.cyan(result.baseBranch)}`);
   } catch (err) {
+    spinner.fail("Failed");
     return `Error: ${err.message}`;
   }
-  await launchClaudeCode(issue, branch);
-  return "Claude Code session ended.";
+  const mergedIntoTaskBranch = isTaskBranch(result.baseBranch);
+  if (!mergedIntoTaskBranch) {
+    const baseBranch = config.baseBranch ?? "main";
+    let pushToMain;
+    try {
+      pushToMain = await select5({
+        message: `Push ${chalk8.cyan(result.baseBranch)} \u2192 ${chalk8.cyan(baseBranch)}?`,
+        choices: [
+          { name: `Yes, push to ${baseBranch}`, value: true },
+          { name: "No, keep in worker branch", value: false }
+        ]
+      });
+    } catch {
+      pushToMain = false;
+    }
+    if (pushToMain) {
+      const mergeSpinner = ora6(`Merging ${result.baseBranch} \u2192 ${baseBranch}\u2026`).start();
+      try {
+        await mergeWorkerIntoBase(config, result.baseBranch, baseBranch);
+        mergeSpinner.succeed(`Merged ${result.baseBranch} \u2192 ${baseBranch}`);
+      } catch (err) {
+        mergeSpinner.fail(`Could not merge to ${baseBranch}: ${err.message}`);
+      }
+    }
+  }
+  let updateWiki = false;
+  try {
+    updateWiki = await select5({
+      message: "Update TECHUNTER.md project overview?",
+      choices: [
+        { name: "Yes, regenerate", value: true },
+        { name: "No, skip", value: false }
+      ]
+    });
+  } catch {
+  }
+  if (updateWiki) {
+    const wikiSpinner = ora6("Regenerating TECHUNTER.md\u2026").start();
+    try {
+      const content = await generateWiki(config);
+      await upsertRepoFile(config, "TECHUNTER.md", content, "docs: update TECHUNTER.md project overview");
+      wikiSpinner.succeed("TECHUNTER.md updated");
+    } catch (err) {
+      wikiSpinner.fail(`Wiki update failed: ${err.message}`);
+    }
+  }
+  const mergeTarget = mergedIntoTaskBranch ? `${result.baseBranch} (sub-task merged, no push to main)` : result.baseBranch;
+  return `Task #${issueNumber} accepted.
+PR #${result.prNumber} merged \u2192 ${mergeTarget}
+Issue closed.`;
 }
-var execute8 = run8;
-var terminal8 = true;
+async function execute6(input, config) {
+  const issueNumber = input["issue_number"];
+  const [me, issue] = await Promise.all([
+    getAuthenticatedUser(config),
+    getTask(config, issueNumber)
+  ]);
+  if (issue.author && issue.author !== me) {
+    return `Permission denied: only the task author (@${issue.author}) can accept task #${issueNumber}.`;
+  }
+  const spinner = ora6(`Merging PR for #${issueNumber}\u2026`).start();
+  try {
+    const result = await acceptTask(config, issueNumber);
+    spinner.stop();
+    return `Task #${issueNumber} accepted.
+PR #${result.prNumber} merged \u2192 ${result.baseBranch}
+Issue closed.`;
+  } catch (err) {
+    spinner.stop();
+    return `Error: ${err.message}`;
+  }
+}
+var terminal6 = true;
 
 // src/tools/reject/index.ts
 var reject_exports = {};
 __export(reject_exports, {
-  definition: () => definition9,
-  execute: () => execute9,
-  run: () => run9,
-  terminal: () => terminal9
+  definition: () => definition7,
+  execute: () => execute7,
+  run: () => run7,
+  terminal: () => terminal7
 });
 init_github();
-import chalk8 from "chalk";
-import { select as select5, input as promptInput3 } from "@inquirer/prompts";
+import chalk9 from "chalk";
+import { select as select6, input as promptInput3 } from "@inquirer/prompts";
 import ora7 from "ora";
 
 // src/tools/reject/prompts.ts
@@ -1738,15 +2251,15 @@ Clear instruction on what to fix and how to re-submit (via /submit).
 async function generateRejectionComment(config, issueNumber, userFeedback) {
   return runSubAgentLoop(
     config,
-    "You are a senior engineer writing a structured code review rejection comment. Use get_task to read the acceptance criteria, get_diff or read_file to inspect the implementation, and get_comments to see prior discussion. Then write the rejection comment.\n\n" + REJECTION_FORMAT,
+    "You are a senior engineer writing a structured code review rejection comment. Use get_task to read the acceptance criteria, get_diff or grep_code to inspect the implementation, and get_comments to see prior discussion. Then write the rejection comment.\n\n" + REJECTION_FORMAT,
     `Write a rejection comment for issue #${issueNumber}.
 Reviewer feedback: ${userFeedback}`,
-    ["get_task", "get_comments", "get_diff", "read_file"]
+    ["get_task", "get_comments", "get_diff", "grep_code"]
   );
 }
 
 // src/tools/reject/index.ts
-var definition9 = {
+var definition7 = {
   type: "function",
   function: {
     name: "reject",
@@ -1761,7 +2274,7 @@ var definition9 = {
     }
   }
 };
-async function run9(input, config) {
+async function run7(input, config) {
   const issueNumber = input["issue_number"];
   const [me, issue] = await Promise.all([
     getAuthenticatedUser(config),
@@ -1779,7 +2292,7 @@ async function run9(input, config) {
     return "Cancelled.";
   }
   if (!feedback.trim()) return "Cancelled.";
-  const divider = chalk8.dim("\u2500".repeat(70));
+  const divider = chalk9.dim("\u2500".repeat(70));
   for (; ; ) {
     const spinner = ora7("Generating rejection comment\u2026").start();
     let comment;
@@ -1791,13 +2304,13 @@ async function run9(input, config) {
       return `Error generating comment: ${err.message}`;
     }
     console.log("\n" + divider);
-    console.log(chalk8.bold(`  Rejection preview \u2014 issue #${issueNumber}`));
+    console.log(chalk9.bold(`  Rejection preview \u2014 issue #${issueNumber}`));
     console.log(divider);
     console.log(renderMarkdown(comment));
     console.log(divider + "\n");
     let decision;
     try {
-      decision = await select5({
+      decision = await select6({
         message: `Post rejection and mark #${issueNumber} as changes-needed?`,
         choices: [
           { name: "Post & Reject", value: "yes" },
@@ -1836,7 +2349,7 @@ async function run9(input, config) {
     return `Task #${issueNumber} rejected. Label changed to changes-needed.`;
   }
 }
-async function execute9(input, config) {
+async function execute7(input, config) {
   const issueNumber = input["issue_number"];
   const feedback = input["feedback"];
   const [me, issue] = await Promise.all([
@@ -1867,150 +2380,181 @@ async function execute9(input, config) {
 Comment posted:
 ${comment}`;
 }
-var terminal9 = true;
+var terminal7 = true;
 
-// src/tools/accept/index.ts
-var accept_exports = {};
-__export(accept_exports, {
-  definition: () => definition10,
-  execute: () => execute10,
-  run: () => run10,
-  terminal: () => terminal10
-});
-init_github();
-import chalk9 from "chalk";
-import { select as select6 } from "@inquirer/prompts";
-import ora8 from "ora";
-var definition10 = {
+// src/tools/review/index.ts
+var definition8 = {
   type: "function",
   function: {
-    name: "accept",
-    description: "Accept an in-review task: merges the PR into your worker branch and closes the issue.",
-    parameters: {
-      type: "object",
-      properties: {
-        issue_number: { type: "number", description: "GitHub issue number to accept" }
-      },
-      required: ["issue_number"]
-    }
+    name: "review",
+    description: "List tasks waiting for your review (submitted by others, created by you), then let you accept or reject one. Equivalent to /review.",
+    parameters: { type: "object", properties: {}, required: [] }
   }
 };
-async function run10(input, config) {
-  let issueNumber = input["issue_number"];
-  if (!issueNumber) {
-    const spinner3 = ora8("Loading tasks for review\u2026").start();
-    let tasks;
-    let me;
-    try {
-      me = await getAuthenticatedUser(config);
-      tasks = await listTasksForReview(config, me);
-      spinner3.stop();
-    } catch (err) {
-      spinner3.stop();
-      return `Error: ${err.message}`;
-    }
-    if (tasks.length === 0) return "No tasks pending review.";
-    try {
-      issueNumber = await select6({
-        message: "Which task to accept?",
-        choices: tasks.map((t) => ({
-          name: `#${t.number}  @${t.assignee ?? "\u2014"}  ${t.title}`,
-          value: t.number
-        }))
-      });
-    } catch {
-      return "Cancelled.";
-    }
-  }
-  const spinner2 = ora8("Verifying permissions\u2026").start();
-  let me2;
-  let issue;
+async function run8(_input, config) {
+  const spinner = ora8("Loading tasks for review\u2026").start();
+  let me;
+  let tasks;
   try {
-    [me2, issue] = await Promise.all([
-      getAuthenticatedUser(config),
-      getTask(config, issueNumber)
-    ]);
-    spinner2.stop();
+    me = await getAuthenticatedUser(config);
+    tasks = await listTasksForReview(config, me);
+    spinner.stop();
   } catch (err) {
-    spinner2.stop();
+    spinner.stop();
     return `Error: ${err.message}`;
   }
-  if (issue.author && issue.author !== me2) {
-    return `Permission denied: only the task author (@${issue.author}) can accept task #${issueNumber}.`;
-  }
-  const targetBranch = makeWorkerBranchName(me2);
-  let confirmed;
+  if (tasks.length === 0) return `No tasks pending review for @${me}.`;
+  let issueNumber;
   try {
-    confirmed = await select6({
-      message: `Merge PR for #${issueNumber} into ${chalk9.cyan(targetBranch)} and close issue?`,
-      choices: [
-        { name: "Yes, accept", value: true },
-        { name: "Cancel", value: false }
-      ]
+    issueNumber = await select7({
+      message: "Select a task to review:",
+      choices: tasks.map((t) => ({
+        name: `#${String(t.number).padEnd(4)} @${t.assignee ?? "\u2014"}  ${t.title}`,
+        value: t.number
+      }))
     });
   } catch {
     return "Cancelled.";
   }
-  if (!confirmed) return "Cancelled.";
-  const spinner = ora8(`Merging PR for #${issueNumber}\u2026`).start();
-  let result;
+  const spinner2 = ora8(`Loading #${issueNumber}\u2026`).start();
+  let pr;
   try {
-    const assigneeWorkerBranch = issue.assignee ? makeWorkerBranchName(issue.assignee) : void 0;
-    result = await acceptTask(config, issueNumber, assigneeWorkerBranch);
-    spinner.succeed(`PR #${result.prNumber} merged into ${targetBranch}`);
+    pr = await getTaskPR(config, issueNumber);
+    spinner2.stop();
   } catch (err) {
-    spinner.fail("Failed");
-    return `Error: ${err.message}`;
+    spinner2.stop();
+    return `Error loading PR: ${err.message}`;
   }
-  const baseBranch = config.baseBranch ?? "main";
-  let pushToMain;
-  try {
-    pushToMain = await select6({
-      message: `Push ${chalk9.cyan(targetBranch)} \u2192 ${chalk9.cyan(baseBranch)}?`,
-      choices: [
-        { name: `Yes, push to ${baseBranch}`, value: true },
-        { name: "No, keep in worker branch", value: false }
-      ]
-    });
-  } catch {
-    pushToMain = false;
+  const divider = chalk10.dim("\u2500".repeat(70));
+  console.log("\n" + divider);
+  if (pr) {
+    console.log(chalk10.bold(`  PR #${pr.number}`) + "  " + chalk10.dim(pr.url));
+    console.log(divider);
+    console.log(renderMarkdown(pr.body));
+  } else {
+    console.log(chalk10.yellow(`  No open PR found for task #${issueNumber}`));
+  }
+  console.log(divider + "\n");
+  for (; ; ) {
+    let action;
+    try {
+      action = await select7({
+        message: "Review action:",
+        choices: [
+          ...pr ? [{ name: "View diff", value: "diff" }] : [],
+          { name: chalk10.green("Accept") + " \u2014 merge PR and close issue", value: "accept" },
+          { name: chalk10.red("Reject") + " \u2014 request changes", value: "reject" },
+          { name: "Nothing, just viewing", value: "none" }
+        ]
+      });
+    } catch {
+      return "Cancelled.";
+    }
+    if (action === "none") return `Viewed task #${issueNumber}.`;
+    if (action === "accept") return run6({ issue_number: issueNumber }, config);
+    if (action === "reject") return run7({ issue_number: issueNumber }, config);
+    if (action === "diff") {
+      const diffSpinner = ora8("Fetching diff\u2026").start();
+      let diff;
+      try {
+        diff = await getTaskPRDiff(config, pr.number);
+        diffSpinner.stop();
+      } catch (err) {
+        diffSpinner.stop();
+        console.log(chalk10.red(`Error fetching diff: ${err.message}`));
+        continue;
+      }
+      console.log("\n" + divider);
+      for (const line of diff.split("\n")) {
+        if (line.startsWith("+") && !line.startsWith("+++")) {
+          process.stdout.write(chalk10.green(line) + "\n");
+        } else if (line.startsWith("-") && !line.startsWith("---")) {
+          process.stdout.write(chalk10.red(line) + "\n");
+        } else if (line.startsWith("@@")) {
+          process.stdout.write(chalk10.cyan(line) + "\n");
+        } else if (line.startsWith("diff ") || line.startsWith("index ") || line.startsWith("+++") || line.startsWith("---")) {
+          process.stdout.write(chalk10.bold(line) + "\n");
+        } else {
+          process.stdout.write(line + "\n");
+        }
+      }
+      console.log(divider + "\n");
+    }
+  }
+}
+var execute8 = run8;
+var terminal8 = true;
+
+// src/tools/refresh/index.ts
+var refresh_exports = {};
+__export(refresh_exports, {
+  definition: () => definition9,
+  execute: () => execute9,
+  run: () => run9,
+  terminal: () => terminal9
+});
+var definition9 = {
+  type: "function",
+  function: {
+    name: "refresh",
+    description: "Reload and display the full task list. Equivalent to /refresh.",
+    parameters: { type: "object", properties: {}, required: [] }
+  }
+};
+async function run9(_input, config) {
+  const tasks = await printTaskList(config);
+  if (tasks.length === 0) return "No tasks found.";
+  const lines = tasks.map((t) => {
+    const status = getStatus(t);
+    const assignee = t.assignee ? `@${t.assignee}` : "\u2014";
+    return `#${t.number}  [${status}]  ${assignee}  ${t.title}`;
+  });
+  return `Tasks (${tasks.length}):
+${lines.join("\n")}`;
+}
+var execute9 = run9;
+var terminal9 = true;
+
+// src/tools/open-code/index.ts
+var open_code_exports = {};
+__export(open_code_exports, {
+  definition: () => definition10,
+  execute: () => execute10,
+  run: () => run10,
+  terminal: () => terminal10
+});
+init_github();
+var definition10 = {
+  type: "function",
+  function: {
+    name: "open_code",
+    description: "Launch Claude Code for the current task branch. Equivalent to /code.",
+    parameters: { type: "object", properties: {}, required: [] }
   }
-  if (pushToMain) {
-    const mergeSpinner = ora8(`Merging ${targetBranch} \u2192 ${baseBranch}\u2026`).start();
-    try {
-      await mergeWorkerIntoBase(config, targetBranch, baseBranch);
-      mergeSpinner.succeed(`Merged ${targetBranch} \u2192 ${baseBranch}`);
-    } catch (err) {
-      mergeSpinner.fail(`Could not merge to ${baseBranch}: ${err.message}`);
-    }
+};
+async function run10(_input, config) {
+  let branch;
+  try {
+    branch = await getCurrentBranch();
+  } catch (err) {
+    return `Error: ${err.message}`;
   }
-  return `Task #${issueNumber} accepted.
-PR #${result.prNumber} merged \u2192 ${targetBranch}${pushToMain ? ` \u2192 ${baseBranch}` : ""}
-Issue closed.`;
-}
-async function execute10(input, config) {
-  const issueNumber = input["issue_number"];
-  const [me, issue] = await Promise.all([
-    getAuthenticatedUser(config),
-    getTask(config, issueNumber)
-  ]);
-  if (issue.author && issue.author !== me) {
-    return `Permission denied: only the task author (@${issue.author}) can accept task #${issueNumber}.`;
+  let issueNum = getConfig().taskState?.activeIssueNumber;
+  if (!issueNum) {
+    const found = await getIssueNumberFromBranch(config, branch);
+    if (!found) return `No active task found (current branch: ${branch}).`;
+    issueNum = found.issueNumber;
   }
-  const targetBranch = makeWorkerBranchName(me);
-  const spinner = ora8(`Merging PR for #${issueNumber}\u2026`).start();
+  let issue;
   try {
-    const assigneeWorkerBranch = issue.assignee ? makeWorkerBranchName(issue.assignee) : void 0;
-    const result = await acceptTask(config, issueNumber, assigneeWorkerBranch);
-    spinner.stop();
-    return `Task #${issueNumber} accepted.
-PR #${result.prNumber} merged \u2192 ${targetBranch}
-Issue closed.`;
+    issue = await getTask(config, issueNum);
   } catch (err) {
-    spinner.stop();
     return `Error: ${err.message}`;
   }
+  await launchClaudeCode(issue, branch);
+  return "Claude Code session ended.";
 }
+var execute10 = run10;
 var terminal10 = true;
 
 // src/tools/edit-task/index.ts
@@ -2022,7 +2566,7 @@ __export(edit_task_exports, {
   terminal: () => terminal11
 });
 init_github();
-import { select as select7, input as promptInput4 } from "@inquirer/prompts";
+import { select as select8, input as promptInput4 } from "@inquirer/prompts";
 import ora9 from "ora";
 var definition11 = {
   type: "function",
@@ -2051,7 +2595,7 @@ async function run11(input, config) {
     }
     if (tasks.length === 0) return "No tasks found.";
     try {
-      issueNumber = await select7({
+      issueNumber = await select8({
         message: "Select task to edit:",
         choices: tasks.map((t) => ({ name: `#${t.number}  [${getStatus(t)}]  ${t.title}`, value: t.number }))
       });
@@ -2108,14 +2652,140 @@ async function execute11(input, config) {
 }
 var terminal11 = true;
 
+// src/tools/wiki/index.ts
+var wiki_exports = {};
+__export(wiki_exports, {
+  definition: () => definition12,
+  execute: () => execute12,
+  run: () => run12,
+  terminal: () => terminal12
+});
+import ora10 from "ora";
+import chalk11 from "chalk";
+import { readFile as readFile2 } from "fs/promises";
+import { select as select9 } from "@inquirer/prompts";
+init_github();
+var WIKI_PATH = "TECHUNTER.md";
+var definition12 = {
+  type: "function",
+  function: {
+    name: "update_wiki",
+    description: "Generate or refresh the project overview document (TECHUNTER.md) by scanning the codebase. The document helps new team members understand what the project does, how it is architected, and how to start contributing. Equivalent to /wiki.",
+    parameters: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  }
+};
+async function readWikiContent(config) {
+  try {
+    return await readFile2(WIKI_PATH, "utf-8");
+  } catch {
+  }
+  return getRepoFile(config, WIKI_PATH);
+}
+function printWiki(content) {
+  const divider = chalk11.dim("\u2500".repeat(70));
+  console.log("\n" + divider);
+  console.log(chalk11.bold("  TECHUNTER.md"));
+  console.log(divider);
+  console.log(renderMarkdown(content));
+  console.log(divider + "\n");
+}
+async function run12(_input, config) {
+  const fetchSpinner = ora10("Checking for existing wiki\u2026").start();
+  const existing = await readWikiContent(config).catch(() => null);
+  fetchSpinner.stop();
+  let action;
+  try {
+    action = await select9({
+      message: "TECHUNTER.md \u2014 what would you like to do?",
+      choices: [
+        ...existing ? [{ name: "View current wiki", value: "view" }] : [],
+        { name: existing ? "Regenerate & commit to repo" : "Generate & commit to repo", value: "generate" },
+        { name: "Cancel", value: "cancel" }
+      ]
+    });
+  } catch {
+    return "Cancelled.";
+  }
+  if (action === "cancel") return "Cancelled.";
+  if (action === "view") {
+    printWiki(existing);
+    return "Displayed TECHUNTER.md.";
+  }
+  const authSpinner = ora10("Checking permissions\u2026").start();
+  let me;
+  let allowed;
+  try {
+    me = await getAuthenticatedUser(config);
+    allowed = await isCollaborator(config, me);
+    authSpinner.stop();
+  } catch (err) {
+    authSpinner.stop();
+    return `Error checking permissions: ${err.message}`;
+  }
+  if (!allowed) {
+    return `Permission denied: only repository collaborators can update the project wiki.`;
+  }
+  const genSpinner = ora10("Analyzing project and generating overview\u2026").start();
+  let content;
+  try {
+    content = await generateWiki(config);
+    genSpinner.stop();
+  } catch (err) {
+    genSpinner.stop();
+    return `Error generating wiki: ${err.message}`;
+  }
+  printWiki(content);
+  let confirm;
+  try {
+    confirm = await select9({
+      message: `Publish to repository as ${WIKI_PATH}?`,
+      choices: [
+        { name: "Yes, commit to repo", value: "publish" },
+        { name: "Cancel", value: "cancel" }
+      ]
+    });
+  } catch {
+    return "Cancelled.";
+  }
+  if (confirm === "cancel") return "Cancelled.";
+  const writeSpinner = ora10(`Writing ${WIKI_PATH}\u2026`).start();
+  try {
+    const url = await upsertRepoFile(config, WIKI_PATH, content, "docs: update TECHUNTER.md project overview");
+    writeSpinner.succeed(`Written: ${url}`);
+    console.log("");
+    return `TECHUNTER.md updated \u2014 ${url}`;
+  } catch (err) {
+    writeSpinner.fail(`Failed: ${err.message}`);
+    return `Error: ${err.message}`;
+  }
+}
+async function execute12(_input, config) {
+  const me = await getAuthenticatedUser(config);
+  if (!await isCollaborator(config, me)) {
+    return `Permission denied: only repository collaborators can update the project wiki.`;
+  }
+  const content = await generateWiki(config);
+  try {
+    const url = await upsertRepoFile(config, WIKI_PATH, content, "docs: update TECHUNTER.md project overview");
+    return `TECHUNTER.md updated \u2014 ${url}`;
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
+}
+var terminal12 = true;
+
 // src/tools/list-tasks/index.ts
 var list_tasks_exports = {};
 __export(list_tasks_exports, {
-  definition: () => definition12,
-  execute: () => execute12
+  definition: () => definition13,
+  execute: () => execute13
 });
 init_github();
-var definition12 = {
+var definition13 = {
   type: "function",
   function: {
     name: "list_tasks",
@@ -2127,7 +2797,7 @@ var definition12 = {
     }
   }
 };
-async function execute12(_input, config) {
+async function execute13(_input, config) {
   const tasks = await listTasks(config);
   if (tasks.length === 0) return "No open tasks.";
   return tasks.map((t) => {
@@ -2140,11 +2810,11 @@ async function execute12(_input, config) {
 // src/tools/get-task/index.ts
 var get_task_exports = {};
 __export(get_task_exports, {
-  definition: () => definition13,
-  execute: () => execute13
+  definition: () => definition14,
+  execute: () => execute14
 });
 init_github();
-var definition13 = {
+var definition14 = {
   type: "function",
   function: {
     name: "get_task",
@@ -2158,7 +2828,7 @@ var definition13 = {
     }
   }
 };
-async function execute13(input, config) {
+async function execute14(input, config) {
   const issue = await getTask(config, input["issue_number"]);
   const status = issue.labels.find((l) => l.startsWith("techunter:"))?.replace("techunter:", "") ?? "unknown";
   const assignee = issue.assignee ? `@${issue.assignee}` : "\u2014";
@@ -2175,12 +2845,12 @@ ${issue.body}`);
 // src/tools/get-comments/index.ts
 var get_comments_exports = {};
 __export(get_comments_exports, {
-  definition: () => definition14,
-  execute: () => execute14
+  definition: () => definition15,
+  execute: () => execute15
 });
 init_github();
-import ora10 from "ora";
-var definition14 = {
+import ora11 from "ora";
+var definition15 = {
   type: "function",
   function: {
     name: "get_comments",
@@ -2195,10 +2865,10 @@ var definition14 = {
     }
   }
 };
-async function execute14(input, config) {
+async function execute15(input, config) {
   const issueNumber = input["issue_number"];
   const limit = input["limit"] ?? 5;
-  const spinner = ora10(`Loading comments for #${issueNumber}...`).start();
+  const spinner = ora11(`Loading comments for #${issueNumber}...`).start();
   try {
     const comments = await listComments(config, issueNumber, limit);
     spinner.stop();
@@ -2217,11 +2887,11 @@ ${lines.join("\n\n")}`;
 // src/tools/get-diff/index.ts
 var get_diff_exports = {};
 __export(get_diff_exports, {
-  definition: () => definition15,
-  execute: () => execute15
+  definition: () => definition16,
+  execute: () => execute16
 });
-import ora11 from "ora";
-var definition15 = {
+import ora12 from "ora";
+var definition16 = {
   type: "function",
   function: {
     name: "get_diff",
@@ -2229,8 +2899,8 @@ var definition15 = {
     parameters: { type: "object", properties: {}, required: [] }
   }
 };
-async function execute15(_input, _config) {
-  const spinner = ora11("Reading git diff...").start();
+async function execute16(_input, _config) {
+  const spinner = ora12("Reading git diff...").start();
   try {
     const diff = await getDiff();
     spinner.stop();
@@ -2244,14 +2914,14 @@ async function execute15(_input, _config) {
 // src/tools/run-command/index.ts
 var run_command_exports = {};
 __export(run_command_exports, {
-  definition: () => definition16,
-  execute: () => execute16
+  definition: () => definition17,
+  execute: () => execute17
 });
 import { exec } from "child_process";
 import { promisify } from "util";
-import ora12 from "ora";
+import ora13 from "ora";
 var execAsync = promisify(exec);
-var definition16 = {
+var definition17 = {
   type: "function",
   function: {
     name: "run_command",
@@ -2265,10 +2935,10 @@ var definition16 = {
     }
   }
 };
-async function execute16(input, _config) {
+async function execute17(input, _config) {
   const command = input["command"];
   const cwd = process.cwd();
-  const spinner = ora12(`$ ${command}`).start();
+  const spinner = ora13(`$ ${command}`).start();
   try {
     const { stdout, stderr } = await execAsync(command, { cwd, timeout: 6e4, maxBuffer: 1024 * 1024 });
     spinner.stop();
@@ -2284,20 +2954,34 @@ ${out || e.message}`;
   }
 }
 
-// src/tools/scan-project/index.ts
-var scan_project_exports = {};
-__export(scan_project_exports, {
-  definition: () => definition17,
-  execute: () => execute17
+// src/tools/list-files/index.ts
+var list_files_exports = {};
+__export(list_files_exports, {
+  definition: () => definition18,
+  execute: () => execute18
 });
-import ora13 from "ora";
-
-// src/lib/project.ts
-import { readFile as readFile2 } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
 import { existsSync } from "fs";
 import path2 from "path";
 import { globby } from "globby";
 import ignore from "ignore";
+var definition18 = {
+  type: "function",
+  function: {
+    name: "list_files",
+    description: "List file paths in the project. Use this first to orient yourself before searching or reading.",
+    parameters: {
+      type: "object",
+      properties: {
+        glob: {
+          type: "string",
+          description: 'Glob pattern to filter results, e.g. "src/**/*.ts". Defaults to all text files.'
+        }
+      },
+      required: []
+    }
+  }
+};
 var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".png",
   ".jpg",
@@ -2310,224 +2994,210 @@ var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".zip",
   ".tar",
   ".gz",
-  ".bz2",
-  ".rar",
   ".exe",
   ".dll",
-  ".so",
-  ".dylib",
   ".woff",
   ".woff2",
   ".ttf",
-  ".otf",
-  ".eot",
   ".mp3",
   ".mp4",
-  ".wav",
-  ".avi",
-  ".mov",
   ".db",
   ".sqlite",
   ".lock"
 ]);
-var ALWAYS_READ = [
-  "README.md",
-  "README.txt",
-  "README",
-  "package.json",
-  "pyproject.toml",
-  "go.mod",
-  "Cargo.toml",
-  "tsconfig.json",
-  "vite.config.ts",
-  "vite.config.js",
-  "webpack.config.js",
-  "rollup.config.js",
-  ".env.example",
-  "docker-compose.yml",
-  "Dockerfile"
-];
-var MAX_TOTAL_BYTES = 8e4;
-var MAX_FILE_BYTES = 15e3;
-async function buildIgnoreFilter(cwd) {
+async function execute18(input, _config) {
+  const glob = input["glob"] ?? "**/*";
+  const cwd = process.cwd();
   const ig = ignore();
   const gitignorePath = path2.join(cwd, ".gitignore");
   if (existsSync(gitignorePath)) {
-    const content = await readFile2(gitignorePath, "utf-8");
-    ig.add(content);
-  }
-  ig.add(["node_modules", "dist", ".git", ".next", "__pycache__", "*.pyc", "build", "coverage"]);
-  return ig;
-}
-async function safeReadFile(filePath, maxBytes = MAX_FILE_BYTES) {
-  try {
-    const content = await readFile2(filePath, "utf-8");
-    if (content.length > maxBytes) {
-      return content.slice(0, maxBytes) + `
-... (truncated at ${maxBytes} chars)`;
-    }
-    return content;
-  } catch {
-    return null;
+    ig.add(await readFile3(gitignorePath, "utf-8"));
   }
+  ig.add(["node_modules", "dist", ".git", ".next", "__pycache__", "build", "coverage"]);
+  const files = await globby(glob, { cwd, dot: false, onlyFiles: true, gitignore: false });
+  const filtered = files.filter((f) => !ig.ignores(f) && !BINARY_EXTENSIONS.has(path2.extname(f).toLowerCase()));
+  if (filtered.length === 0) return `No files matched: ${glob}`;
+  return `${filtered.length} file(s):
+${filtered.join("\n")}`;
 }
-function isBinaryFile(filePath) {
-  const ext = path2.extname(filePath).toLowerCase();
-  return BINARY_EXTENSIONS.has(ext);
-}
-function buildFileTree(files) {
-  const tree = {};
-  for (const file of files) {
-    const dir = path2.dirname(file);
-    if (!tree[dir]) tree[dir] = [];
-    tree[dir].push(path2.basename(file));
-  }
-  const lines = [];
-  const rootFiles = tree["."] ?? [];
-  for (const f of rootFiles) lines.push(f);
-  const dirs = Object.keys(tree).filter((d) => d !== ".").sort();
-  for (const dir of dirs) {
-    lines.push(`${dir}/`);
-    for (const f of tree[dir]) {
-      lines.push(`  ${f}`);
-    }
-  }
-  return lines.join("\n");
-}
-function scoreRelevance(filePath, keywords) {
-  const lower = filePath.toLowerCase();
-  let score = 0;
-  for (const kw of keywords) {
-    if (lower.includes(kw)) score += 1;
-  }
-  return score;
-}
-async function buildProjectContext(cwd, issueTitle, issueBody) {
-  const ig = await buildIgnoreFilter(cwd);
-  const allFiles = await globby("**/*", {
-    cwd,
-    gitignore: false,
-    // We handle ignore ourselves
-    dot: false,
-    onlyFiles: true
-  });
-  const filtered = allFiles.filter((f) => !ig.ignores(f) && !isBinaryFile(f));
-  const fileTree = buildFileTree(filtered);
-  const issueText = `${issueTitle} ${issueBody}`.toLowerCase();
-  const keywords = issueText.replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 3);
-  const keyFiles = {};
-  let totalBytes = 0;
-  for (const always of ALWAYS_READ) {
-    if (totalBytes >= MAX_TOTAL_BYTES) break;
-    const fullPath = path2.join(cwd, always);
-    if (!existsSync(fullPath)) continue;
-    const content = await safeReadFile(fullPath);
-    if (content !== null) {
-      keyFiles[always] = content;
-      totalBytes += content.length;
-    }
-  }
-  const scored = filtered.filter((f) => !ALWAYS_READ.includes(f) && !ALWAYS_READ.includes(path2.basename(f))).map((f) => ({ file: f, score: scoreRelevance(f, keywords) })).filter((x) => x.score > 0).sort((a, b) => b.score - a.score).slice(0, 10);
-  for (const { file } of scored) {
-    if (totalBytes >= MAX_TOTAL_BYTES) break;
-    const fullPath = path2.join(cwd, file);
-    const content = await safeReadFile(fullPath);
-    if (content !== null) {
-      keyFiles[file] = content;
-      totalBytes += content.length;
-    }
-  }
-  return { fileTree, keyFiles };
-}
-
-// src/tools/scan-project/index.ts
-var definition17 = {
+
+// src/tools/grep-code/index.ts
+var grep_code_exports = {};
+__export(grep_code_exports, {
+  definition: () => definition19,
+  execute: () => execute19
+});
+import { readFile as readFile4 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import path3 from "path";
+import { globby as globby2 } from "globby";
+import ignore2 from "ignore";
+var definition19 = {
   type: "function",
   function: {
-    name: "scan_project",
-    description: "Scan the current project directory: returns the file tree and contents of the most relevant files. Call this when creating a new task to understand the codebase before writing the task body and guide.",
+    name: "grep_code",
+    description: "Search for a pattern across files, or read a specific line range from a file.\n- Search mode: provide `pattern` \u2014 returns matching lines with context.\n- Read-range mode: provide `file_glob` (single file) + `start_line` + `end_line`, no `pattern` \u2014 read an exact section. Use after grep has given you line numbers.",
     parameters: {
       type: "object",
       properties: {
-        focus: {
+        pattern: {
           type: "string",
-          description: "Keywords describing the task. Used to prioritise which files to read."
+          description: "Regex or plain text to search for (case-insensitive). Omit for read-range mode."
+        },
+        file_glob: {
+          type: "string",
+          description: 'Glob to restrict which files to search or read, e.g. "src/**/*.ts" or "src/lib/agent.ts". Defaults to all text files.'
+        },
+        context_lines: {
+          type: "number",
+          description: "Lines of context before/after each match (search mode only). Default: 2."
+        },
+        max_results: {
+          type: "number",
+          description: "Max matches to return (search mode only). Default: 50."
+        },
+        start_line: {
+          type: "number",
+          description: "First line to read, 1-based (read-range mode). Requires file_glob pointing to a single file."
+        },
+        end_line: {
+          type: "number",
+          description: "Last line to read, 1-based (read-range mode)."
         }
       },
       required: []
     }
   }
 };
-async function execute17(input, _config) {
-  const focus = input["focus"] ?? "";
-  const spinner = ora13("Scanning project...").start();
-  try {
-    const cwd = process.cwd();
-    const context = await buildProjectContext(cwd, focus, "");
-    spinner.stop();
-    const fileCount = context.fileTree.split("\n").filter(Boolean).length;
-    const readCount = Object.keys(context.keyFiles).length;
-    const totalBytes = Object.values(context.keyFiles).reduce((s, c) => s + c.length, 0);
-    const summary = `Scanned ${fileCount} files \xB7 ${readCount} read \xB7 ${(totalBytes / 1024).toFixed(1)} KB`;
-    const parts = [summary, `## File tree
-\`\`\`
-${context.fileTree}
-\`\`\``];
-    for (const [filePath, content] of Object.entries(context.keyFiles)) {
-      parts.push(`## ${filePath}
-\`\`\`
-${content}
-\`\`\``);
-    }
-    return parts.join("\n\n");
-  } catch (err) {
-    spinner.stop();
-    throw err;
+async function buildIgnore(cwd) {
+  const ig = ignore2();
+  const gitignorePath = path3.join(cwd, ".gitignore");
+  if (existsSync2(gitignorePath)) {
+    ig.add(await readFile4(gitignorePath, "utf-8"));
   }
+  ig.add(["node_modules", "dist", ".git", ".next", "__pycache__", "build", "coverage"]);
+  return ig;
 }
-
-// src/tools/read-file/index.ts
-var read_file_exports = {};
-__export(read_file_exports, {
-  definition: () => definition18,
-  execute: () => execute18
-});
-import { readFile as readFile3 } from "fs/promises";
-import path3 from "path";
-var definition18 = {
-  type: "function",
-  function: {
-    name: "read_file",
-    description: "Read the full contents of a specific file in the project.",
-    parameters: {
-      type: "object",
-      properties: {
-        path: { type: "string", description: "File path relative to the project root" }
-      },
-      required: ["path"]
-    }
+var BINARY_EXTENSIONS2 = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".svg",
+  ".ico",
+  ".webp",
+  ".pdf",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".exe",
+  ".dll",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".mp3",
+  ".mp4",
+  ".db",
+  ".sqlite",
+  ".lock"
+]);
+function isText(f) {
+  return !BINARY_EXTENSIONS2.has(path3.extname(f).toLowerCase());
+}
+var MAX_RANGE_LINES = 300;
+async function execute19(input, _config) {
+  const pattern = input["pattern"] ?? "";
+  const fileGlob = input["file_glob"] ?? "**/*";
+  const contextLines = Math.min(input["context_lines"] ?? 2, 5);
+  const maxResults = Math.min(input["max_results"] ?? 50, 200);
+  const startLine = input["start_line"];
+  const endLine = input["end_line"];
+  const cwd = process.cwd();
+  if (!pattern && startLine != null && endLine != null) {
+    const files = await globby2(fileGlob, { cwd, dot: false, onlyFiles: true, gitignore: false });
+    if (files.length === 0) return `No file matched: ${fileGlob}`;
+    if (files.length > 1) return `file_glob matched ${files.length} files \u2014 narrow it to a single file for read-range mode.`;
+    const raw = await readFile4(path3.join(cwd, files[0]), "utf-8");
+    const lines = raw.split("\n");
+    const total = lines.length;
+    const from = Math.max(1, startLine);
+    const to = Math.min(total, endLine, from + MAX_RANGE_LINES - 1);
+    const numbered = lines.slice(from - 1, to).map((l, i) => `${String(from + i).padStart(5)}: ${l}`).join("\n");
+    const truncNote = to < Math.min(total, endLine) ? `
+\u2026 (use start_line=${to + 1} to continue)` : "";
+    return `${files[0]} \u2014 lines ${from}\u2013${to} of ${total}:
+\`\`\`
+${numbered}
+\`\`\`${truncNote}`;
   }
-};
-async function execute18(input, _config) {
-  const filePath = input["path"];
+  if (!pattern) return "Provide a `pattern` to search, or `start_line` + `end_line` for read-range mode. Use list_files to browse file paths.";
+  const ig = await buildIgnore(cwd);
+  let regex;
   try {
-    const fullPath = path3.join(process.cwd(), filePath);
-    const content = await readFile3(fullPath, "utf-8");
-    return content.length > 15e3 ? content.slice(0, 15e3) + "\n\n... (truncated)" : content;
-  } catch (err) {
-    return `Error reading file: ${err.message}`;
+    regex = new RegExp(pattern, "i");
+  } catch {
+    regex = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
+  }
+  const allFiles = await globby2(fileGlob, { cwd, dot: false, onlyFiles: true, gitignore: false });
+  const filtered = allFiles.filter((f) => !ig.ignores(f) && isText(f));
+  const matches = [];
+  let totalMatches = 0;
+  for (const file of filtered) {
+    if (totalMatches >= maxResults) break;
+    let content;
+    try {
+      content = await readFile4(path3.join(cwd, file), "utf-8");
+    } catch {
+      continue;
+    }
+    const lines = content.split("\n");
+    const hitLines = [];
+    for (let i = 0; i < lines.length; i++) {
+      if (regex.test(lines[i])) hitLines.push(i);
+    }
+    if (hitLines.length === 0) continue;
+    const ranges = [];
+    for (const hit of hitLines) {
+      const s = Math.max(0, hit - contextLines);
+      const e = Math.min(lines.length - 1, hit + contextLines);
+      if (ranges.length > 0 && s <= ranges[ranges.length - 1][1] + 1) {
+        ranges[ranges.length - 1][1] = e;
+      } else {
+        ranges.push([s, e]);
+      }
+    }
+    const snippets = [];
+    for (const [s, e] of ranges) {
+      if (totalMatches >= maxResults) break;
+      snippets.push(
+        lines.slice(s, e + 1).map((l, i) => {
+          const n = s + i + 1;
+          return `${regex.test(l) ? ">" : " "} ${String(n).padStart(4)}: ${l}`;
+        }).join("\n")
+      );
+      totalMatches += hitLines.filter((h) => h >= s && h <= e).length;
+    }
+    if (snippets.length > 0) {
+      matches.push(`## ${file}
+\`\`\`
+${snippets.join("\n---\n")}
+\`\`\``);
+    }
   }
+  if (matches.length === 0) return `No matches found for: ${pattern}`;
+  const header = `Found matches in ${matches.length} file(s) (${totalMatches} match${totalMatches === 1 ? "" : "es"})${totalMatches >= maxResults ? " \u2014 limit reached" : ""}:`;
+  return [header, ...matches].join("\n\n");
 }
 
 // src/tools/ask-user/index.ts
 var ask_user_exports = {};
 __export(ask_user_exports, {
-  definition: () => definition19,
-  execute: () => execute19
+  definition: () => definition20,
+  execute: () => execute20
 });
-import chalk10 from "chalk";
-import { select as select8, input as promptInput5 } from "@inquirer/prompts";
-var definition19 = {
+import chalk12 from "chalk";
+import { select as select10, input as promptInput5 } from "@inquirer/prompts";
+var definition20 = {
   type: "function",
   function: {
     name: "ask_user",
@@ -2546,24 +3216,24 @@ var definition19 = {
     }
   }
 };
-async function execute19(input, _config) {
+async function execute20(input, _config) {
   const question = input["question"];
   const options = input["options"];
   const OTHER = "__other__";
   console.log("");
-  console.log(chalk10.dim("  \u250C\u2500 Agent question " + "\u2500".repeat(51)));
-  console.log(chalk10.dim("  \u2502"));
+  console.log(chalk12.dim("  \u250C\u2500 Agent question " + "\u2500".repeat(51)));
+  console.log(chalk12.dim("  \u2502"));
   for (const line of question.split("\n")) {
-    console.log(chalk10.dim("  \u2502 ") + line);
+    console.log(chalk12.dim("  \u2502 ") + line);
   }
-  console.log(chalk10.dim("  \u2514" + "\u2500".repeat(67)));
+  console.log(chalk12.dim("  \u2514" + "\u2500".repeat(67)));
   let answer;
   try {
-    const chosen = await select8({
+    const chosen = await select10({
       message: " ",
       choices: [
         ...options.map((o) => ({ name: o, value: o })),
-        { name: chalk10.dim("Other (describe below)"), value: OTHER }
+        { name: chalk12.dim("Other (describe below)"), value: OTHER }
       ]
     });
     answer = chosen === OTHER ? await promptInput5({ message: "Your answer:" }) : chosen;
@@ -2588,14 +3258,15 @@ var toolModules = [
   reject_exports,
   accept_exports,
   edit_task_exports,
+  wiki_exports,
   // Low-level tools
   list_tasks_exports,
   get_task_exports,
   get_comments_exports,
   get_diff_exports,
   run_command_exports,
-  scan_project_exports,
-  read_file_exports,
+  list_files_exports,
+  grep_code_exports,
   ask_user_exports
 ];