techunter 0.1.11 → 1.0.1

package/dist/mcp.js

@@ -39,12 +39,22 @@ __export(github_exports, {
   createTask: () => createTask,
   editTask: () => editTask,
   embedBaseCommit: () => embedBaseCommit,
+  embedTargetBranch: () => embedTargetBranch,
   ensureLabels: () => ensureLabels,
+  ensureRemoteBranch: () => ensureRemoteBranch,
   extractBaseCommit: () => extractBaseCommit,
+  extractTargetBranch: () => extractTargetBranch,
   formatGuideAsMarkdown: () => formatGuideAsMarkdown,
   getAuthenticatedUser: () => getAuthenticatedUser,
+  getBranchHeadSha: () => getBranchHeadSha,
   getDefaultBranch: () => getDefaultBranch,
+  getIssueNumberFromBranch: () => getIssueNumberFromBranch,
+  getOpenSubtasks: () => getOpenSubtasks,
+  getRepoFile: () => getRepoFile,
   getTask: () => getTask,
+  getTaskBranch: () => getTaskBranch,
+  getTaskPR: () => getTaskPR,
+  getTaskPRDiff: () => getTaskPRDiff,
   isCollaborator: () => isCollaborator,
   listComments: () => listComments,
   listMyTasks: () => listMyTasks,
@@ -52,9 +62,11 @@ __export(github_exports, {
   listTasksForReview: () => listTasksForReview,
   markInReview: () => markInReview,
   mergeWorkerIntoBase: () => mergeWorkerIntoBase,
+  moveTask: () => moveTask,
   postComment: () => postComment,
   postGuideComment: () => postGuideComment,
-  rejectTask: () => rejectTask
+  rejectTask: () => rejectTask,
+  upsertRepoFile: () => upsertRepoFile
 });
 import { Octokit } from "@octokit/rest";
 import { fetch as undiciFetch } from "undici";
@@ -117,11 +129,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 +157,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 +248,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 +281,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 +400,146 @@ 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 getTaskBranch(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 pr.head.ref;
+  const { data: branches } = await octokit.repos.listBranches({ owner, repo, per_page: 100 });
+  const taskBranch = branches.find((b) => new RegExp(`^task-${issueNumber}-`).test(b.name));
+  return taskBranch?.name ?? null;
+}
+async function getBranchHeadSha(config, branchName) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  try {
+    const { data } = await octokit.repos.getBranch({ owner, repo, branch: branchName });
+    return data.commit.sha;
+  } catch {
+    return null;
+  }
+}
+async function moveTask(config, issueNumber, newTargetBranch, newBaseCommit) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  const { data } = await octokit.issues.get({ owner, repo, issue_number: issueNumber });
+  let body = data.body ?? "";
+  body = body.replace(/\n*<!-- techunter-base:[a-f0-9]{7,40} -->/g, "");
+  body = body.replace(/\n*<!-- techunter-target:[^\s>]+ -->/g, "");
+  body = embedBaseCommit(body, newBaseCommit);
+  body = embedTargetBranch(body, newTargetBranch);
+  await octokit.issues.update({ owner, repo, issue_number: issueNumber, body });
+}
+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 = 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 +556,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 +593,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 +724,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 +765,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 +853,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 +888,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);
@@ -873,9 +1094,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 +1116,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 +1186,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 +1222,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 +1250,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 +1275,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 +1463,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 +1491,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 +1501,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 +1569,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 +1649,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}`;
 }
@@ -1389,6 +1748,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 +1914,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 +1967,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 +2019,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: [] }
+
+// 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"]
+  );
+}
+
+// src/tools/accept/index.ts
+var definition6 = {
+  type: "function",
+  function: {
+    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 run6(_input, config) {
-  const spinner = ora6("Loading tasks for review\u2026").start();
+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 {
-    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")}`;
+    [me2, issue] = await Promise.all([
+      getAuthenticatedUser(config),
+      getTask(config, issueNumber)
+    ]);
+    spinner2.stop();
   } catch (err) {
-    spinner.stop();
+    spinner2.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: [] }
+  if (issue.author && issue.author !== me2) {
+    return `Permission denied: only the task author (@${issue.author}) can accept task #${issueNumber}.`;
   }
-};
-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")}`;
-}
-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 = {
-  type: "function",
-  function: {
-    name: "open_code",
-    description: "Launch Claude Code for the current task branch. Equivalent to /code.",
-    parameters: { type: "object", properties: {}, required: [] }
+  let confirmed;
+  try {
+    confirmed = await select5({
+      message: `Merge PR for #${issueNumber} and close issue?`,
+      choices: [
+        { name: "Yes, accept", value: true },
+        { name: "Cancel", value: false }
+      ]
+    });
+  } catch {
+    return "Cancelled.";
   }
-};
-async function run8(_input, config) {
-  let branch;
+  if (!confirmed) return "Cancelled.";
+  const spinner = ora6(`Merging PR for #${issueNumber}\u2026`).start();
+  let result;
   try {
-    branch = await getCurrentBranch();
+    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}`;
   }
-  const match = branch.match(/^task-(\d+)-/);
-  if (!match) return `Not on a task branch (current: ${branch}).`;
-  const issueNum = parseInt(match[1], 10);
-  let issue;
+  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 {
-    issue = await getTask(config, issueNum);
+    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.`;
+}
+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}`;
   }
-  await launchClaudeCode(issue, branch);
-  return "Claude Code session ended.";
 }
-var execute8 = run8;
-var terminal8 = true;
+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
@@ -1746,7 +2293,7 @@ Reviewer feedback: ${userFeedback}`,
 }
 
 // src/tools/reject/index.ts
-var definition9 = {
+var definition7 = {
   type: "function",
   function: {
     name: "reject",
@@ -1761,7 +2308,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 +2326,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 +2338,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 +2383,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 +2414,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.";
-    }
+async function run8(_input, config) {
+  const spinner = ora8("Loading tasks for review\u2026").start();
+  let me;
+  let tasks;
+  try {
+    me = await getAuthenticatedUser(config);
+    tasks = await listTasksForReview(config, me);
+    spinner.stop();
+  } catch (err) {
+    spinner.stop();
+    return `Error: ${err.message}`;
   }
-  const spinner2 = ora8("Verifying permissions\u2026").start();
-  let me2;
-  let issue;
+  if (tasks.length === 0) return `No tasks pending review for @${me}.`;
+  let issueNumber;
   try {
-    [me2, issue] = await Promise.all([
-      getAuthenticatedUser(config),
-      getTask(config, issueNumber)
-    ]);
+    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.";
+  }
+  const spinner2 = ora8(`Loading #${issueNumber}\u2026`).start();
+  let pr;
+  try {
+    pr = await getTaskPR(config, issueNumber);
     spinner2.stop();
   } catch (err) {
     spinner2.stop();
-    return `Error: ${err.message}`;
+    return `Error loading PR: ${err.message}`;
   }
-  if (issue.author && issue.author !== me2) {
-    return `Permission denied: only the task author (@${issue.author}) can accept task #${issueNumber}.`;
+  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: [] }
   }
-  const targetBranch = makeWorkerBranchName(me2);
-  let confirmed;
-  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 }
-      ]
-    });
-  } catch {
-    return "Cancelled.";
+};
+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 (!confirmed) return "Cancelled.";
-  const spinner = ora8(`Merging PR for #${issueNumber}\u2026`).start();
-  let result;
+};
+async function run10(_input, config) {
+  let branch;
   try {
-    const assigneeWorkerBranch = issue.assignee ? makeWorkerBranchName(issue.assignee) : void 0;
-    result = await acceptTask(config, issueNumber, assigneeWorkerBranch);
-    spinner.succeed(`PR #${result.prNumber} merged into ${targetBranch}`);
+    branch = await getCurrentBranch();
   } catch (err) {
-    spinner.fail("Failed");
     return `Error: ${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;
-  }
-  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}`);
-    }
-  }
-  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 +2600,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 +2629,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 +2686,264 @@ async function execute11(input, config) {
 }
 var terminal11 = true;
 
+// src/tools/move-task/index.ts
+var move_task_exports = {};
+__export(move_task_exports, {
+  definition: () => definition12,
+  execute: () => execute12,
+  run: () => run12,
+  terminal: () => terminal12
+});
+init_github();
+import { select as select9 } from "@inquirer/prompts";
+import ora10 from "ora";
+import chalk11 from "chalk";
+var definition12 = {
+  type: "function",
+  function: {
+    name: "move_task",
+    description: "Move one of your own published tasks to be a sub-task of another task. Updates the target branch and base commit so executors sync from the new parent HEAD. Equivalent to /move.",
+    parameters: {
+      type: "object",
+      properties: {
+        issue_number: { type: "number", description: "Issue number of the task to move." },
+        parent_issue_number: { type: "number", description: "Issue number of the new parent task." }
+      },
+      required: ["issue_number", "parent_issue_number"]
+    }
+  }
+};
+async function run12(input, config) {
+  const me = await getAuthenticatedUser(config);
+  const allTasks = await listTasks(config);
+  let issueNumber = input["issue_number"];
+  let taskToMove;
+  if (issueNumber) {
+    try {
+      taskToMove = await getTask(config, issueNumber);
+    } catch (err) {
+      return `Error loading task #${issueNumber}: ${err.message}`;
+    }
+    if (taskToMove.author !== me) {
+      return `Task #${issueNumber} was not authored by you \u2014 you can only move your own tasks.`;
+    }
+  } else {
+    const myTasks = allTasks.filter((t) => t.author === me);
+    if (myTasks.length === 0) return "No tasks you authored are available to move.";
+    try {
+      issueNumber = await select9({
+        message: "Select task to move:",
+        choices: myTasks.map((t) => ({
+          name: `#${t.number}  [${getStatus(t)}]  ${t.title}`,
+          value: t.number
+        }))
+      });
+    } catch {
+      return "Cancelled.";
+    }
+    taskToMove = myTasks.find((t) => t.number === issueNumber);
+  }
+  const candidates = allTasks.filter((t) => t.number !== taskToMove.number);
+  const resolveSpinner = ora10("Finding parent task branches\u2026").start();
+  const parents = [];
+  for (const t of candidates) {
+    const branch = await getTaskBranch(config, t.number);
+    if (branch) parents.push({ task: t, branch });
+  }
+  resolveSpinner.stop();
+  if (parents.length === 0) {
+    return "No other tasks with known branches are available as a parent.";
+  }
+  let parentIssueNumber = input["parent_issue_number"];
+  let chosen;
+  if (parentIssueNumber) {
+    const found = parents.find((p) => p.task.number === parentIssueNumber);
+    if (!found) {
+      return `Task #${parentIssueNumber} is not available as a parent (no branch found or not open).`;
+    }
+    chosen = found;
+  } else {
+    try {
+      const selectedBranch = await select9({
+        message: `Move #${taskToMove.number} under which task?`,
+        choices: parents.map((p) => ({
+          name: `#${p.task.number}  [${getStatus(p.task)}]  ${p.task.title}  ${chalk11.dim("\u2192 " + p.branch)}`,
+          value: p.branch
+        }))
+      });
+      chosen = parents.find((p) => p.branch === selectedBranch);
+    } catch {
+      return "Cancelled.";
+    }
+  }
+  const sha = await getBranchHeadSha(config, chosen.branch);
+  if (!sha) {
+    return `Could not resolve HEAD of branch ${chosen.branch} \u2014 does it exist on the remote?`;
+  }
+  const spinner = ora10(`Moving #${taskToMove.number} under #${chosen.task.number}\u2026`).start();
+  try {
+    await moveTask(config, taskToMove.number, chosen.branch, sha);
+    spinner.succeed(
+      `Task #${taskToMove.number} moved under #${chosen.task.number} "${chosen.task.title}"
+  target: ${chalk11.cyan(chosen.branch)}  base: ${chalk11.dim(sha.slice(0, 7))}`
+    );
+    return `Task #${taskToMove.number} moved under #${chosen.task.number} (branch: ${chosen.branch}, base: ${sha.slice(0, 7)})`;
+  } catch (err) {
+    spinner.fail(`Failed: ${err.message}`);
+    return `Error: ${err.message}`;
+  }
+}
+async function execute12(input, config) {
+  const me = await getAuthenticatedUser(config);
+  const issueNumber = input["issue_number"];
+  const parentIssueNumber = input["parent_issue_number"];
+  const task = await getTask(config, issueNumber);
+  if (task.author !== me) {
+    return `Task #${issueNumber} was not authored by you \u2014 you can only move your own tasks.`;
+  }
+  const branch = await getTaskBranch(config, parentIssueNumber);
+  if (!branch) return `No branch found for parent task #${parentIssueNumber}.`;
+  const sha = await getBranchHeadSha(config, branch);
+  if (!sha) return `Could not resolve HEAD of branch ${branch}.`;
+  await moveTask(config, issueNumber, branch, sha);
+  return `Task #${issueNumber} moved under #${parentIssueNumber} (branch: ${branch}, base: ${sha.slice(0, 7)})`;
+}
+var terminal12 = true;
+
+// src/tools/wiki/index.ts
+var wiki_exports = {};
+__export(wiki_exports, {
+  definition: () => definition13,
+  execute: () => execute13,
+  run: () => run13,
+  terminal: () => terminal13
+});
+import ora11 from "ora";
+import chalk12 from "chalk";
+import { readFile as readFile2 } from "fs/promises";
+import { select as select10 } from "@inquirer/prompts";
+init_github();
+var WIKI_PATH = "TECHUNTER.md";
+var definition13 = {
+  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 = chalk12.dim("\u2500".repeat(70));
+  console.log("\n" + divider);
+  console.log(chalk12.bold("  TECHUNTER.md"));
+  console.log(divider);
+  console.log(renderMarkdown(content));
+  console.log(divider + "\n");
+}
+async function run13(_input, config) {
+  const fetchSpinner = ora11("Checking for existing wiki\u2026").start();
+  const existing = await readWikiContent(config).catch(() => null);
+  fetchSpinner.stop();
+  let action;
+  try {
+    action = await select10({
+      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 = ora11("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 = ora11("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 select10({
+      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 = ora11(`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 execute13(_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 terminal13 = true;
+
 // src/tools/list-tasks/index.ts
 var list_tasks_exports = {};
 __export(list_tasks_exports, {
-  definition: () => definition12,
-  execute: () => execute12
+  definition: () => definition14,
+  execute: () => execute14
 });
 init_github();
-var definition12 = {
+var definition14 = {
   type: "function",
   function: {
     name: "list_tasks",
@@ -2127,7 +2955,7 @@ var definition12 = {
     }
   }
 };
-async function execute12(_input, config) {
+async function execute14(_input, config) {
   const tasks = await listTasks(config);
   if (tasks.length === 0) return "No open tasks.";
   return tasks.map((t) => {
@@ -2140,11 +2968,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: () => definition15,
+  execute: () => execute15
 });
 init_github();
-var definition13 = {
+var definition15 = {
   type: "function",
   function: {
     name: "get_task",
@@ -2158,7 +2986,7 @@ var definition13 = {
     }
   }
 };
-async function execute13(input, config) {
+async function execute15(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 +3003,12 @@ ${issue.body}`);
 // src/tools/get-comments/index.ts
 var get_comments_exports = {};
 __export(get_comments_exports, {
-  definition: () => definition14,
-  execute: () => execute14
+  definition: () => definition16,
+  execute: () => execute16
 });
 init_github();
-import ora10 from "ora";
-var definition14 = {
+import ora12 from "ora";
+var definition16 = {
   type: "function",
   function: {
     name: "get_comments",
@@ -2195,10 +3023,10 @@ var definition14 = {
     }
   }
 };
-async function execute14(input, config) {
+async function execute16(input, config) {
   const issueNumber = input["issue_number"];
   const limit = input["limit"] ?? 5;
-  const spinner = ora10(`Loading comments for #${issueNumber}...`).start();
+  const spinner = ora12(`Loading comments for #${issueNumber}...`).start();
   try {
     const comments = await listComments(config, issueNumber, limit);
     spinner.stop();
@@ -2217,11 +3045,11 @@ ${lines.join("\n\n")}`;
 // src/tools/get-diff/index.ts
 var get_diff_exports = {};
 __export(get_diff_exports, {
-  definition: () => definition15,
-  execute: () => execute15
+  definition: () => definition17,
+  execute: () => execute17
 });
-import ora11 from "ora";
-var definition15 = {
+import ora13 from "ora";
+var definition17 = {
   type: "function",
   function: {
     name: "get_diff",
@@ -2229,8 +3057,8 @@ var definition15 = {
     parameters: { type: "object", properties: {}, required: [] }
   }
 };
-async function execute15(_input, _config) {
-  const spinner = ora11("Reading git diff...").start();
+async function execute17(_input, _config) {
+  const spinner = ora13("Reading git diff...").start();
   try {
     const diff = await getDiff();
     spinner.stop();
@@ -2244,14 +3072,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: () => definition18,
+  execute: () => execute18
 });
 import { exec } from "child_process";
 import { promisify } from "util";
-import ora12 from "ora";
+import ora14 from "ora";
 var execAsync = promisify(exec);
-var definition16 = {
+var definition18 = {
   type: "function",
   function: {
     name: "run_command",
@@ -2265,10 +3093,10 @@ var definition16 = {
     }
   }
 };
-async function execute16(input, _config) {
+async function execute18(input, _config) {
   const command = input["command"];
   const cwd = process.cwd();
-  const spinner = ora12(`$ ${command}`).start();
+  const spinner = ora14(`$ ${command}`).start();
   try {
     const { stdout, stderr } = await execAsync(command, { cwd, timeout: 6e4, maxBuffer: 1024 * 1024 });
     spinner.stop();
@@ -2287,15 +3115,15 @@ ${out || e.message}`;
 // src/tools/list-files/index.ts
 var list_files_exports = {};
 __export(list_files_exports, {
-  definition: () => definition17,
-  execute: () => execute17
+  definition: () => definition19,
+  execute: () => execute19
 });
-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 definition17 = {
+var definition19 = {
   type: "function",
   function: {
     name: "list_files",
@@ -2335,13 +3163,13 @@ var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".sqlite",
   ".lock"
 ]);
-async function execute17(input, _config) {
+async function execute19(input, _config) {
   const glob = input["glob"] ?? "**/*";
   const cwd = process.cwd();
   const ig = ignore();
   const gitignorePath = path2.join(cwd, ".gitignore");
   if (existsSync(gitignorePath)) {
-    ig.add(await readFile2(gitignorePath, "utf-8"));
+    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 });
@@ -2354,15 +3182,15 @@ ${filtered.join("\n")}`;
 // src/tools/grep-code/index.ts
 var grep_code_exports = {};
 __export(grep_code_exports, {
-  definition: () => definition18,
-  execute: () => execute18
+  definition: () => definition20,
+  execute: () => execute20
 });
-import { readFile as readFile3 } from "fs/promises";
+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 definition18 = {
+var definition20 = {
   type: "function",
   function: {
     name: "grep_code",
@@ -2403,7 +3231,7 @@ async function buildIgnore(cwd) {
   const ig = ignore2();
   const gitignorePath = path3.join(cwd, ".gitignore");
   if (existsSync2(gitignorePath)) {
-    ig.add(await readFile3(gitignorePath, "utf-8"));
+    ig.add(await readFile4(gitignorePath, "utf-8"));
   }
   ig.add(["node_modules", "dist", ".git", ".next", "__pycache__", "build", "coverage"]);
   return ig;
@@ -2435,7 +3263,7 @@ function isText(f) {
   return !BINARY_EXTENSIONS2.has(path3.extname(f).toLowerCase());
 }
 var MAX_RANGE_LINES = 300;
-async function execute18(input, _config) {
+async function execute20(input, _config) {
   const pattern = input["pattern"] ?? "";
   const fileGlob = input["file_glob"] ?? "**/*";
   const contextLines = Math.min(input["context_lines"] ?? 2, 5);
@@ -2447,7 +3275,7 @@ async function execute18(input, _config) {
     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 readFile3(path3.join(cwd, files[0]), "utf-8");
+    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);
@@ -2476,7 +3304,7 @@ ${numbered}
     if (totalMatches >= maxResults) break;
     let content;
     try {
-      content = await readFile3(path3.join(cwd, file), "utf-8");
+      content = await readFile4(path3.join(cwd, file), "utf-8");
     } catch {
       continue;
     }
@@ -2522,12 +3350,12 @@ ${snippets.join("\n---\n")}
 // src/tools/ask-user/index.ts
 var ask_user_exports = {};
 __export(ask_user_exports, {
-  definition: () => definition19,
-  execute: () => execute19
+  definition: () => definition21,
+  execute: () => execute21
 });
-import chalk10 from "chalk";
-import { select as select8, input as promptInput5 } from "@inquirer/prompts";
-var definition19 = {
+import chalk13 from "chalk";
+import { select as select11, input as promptInput5 } from "@inquirer/prompts";
+var definition21 = {
   type: "function",
   function: {
     name: "ask_user",
@@ -2546,24 +3374,24 @@ var definition19 = {
     }
   }
 };
-async function execute19(input, _config) {
+async function execute21(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(chalk13.dim("  \u250C\u2500 Agent question " + "\u2500".repeat(51)));
+  console.log(chalk13.dim("  \u2502"));
   for (const line of question.split("\n")) {
-    console.log(chalk10.dim("  \u2502 ") + line);
+    console.log(chalk13.dim("  \u2502 ") + line);
   }
-  console.log(chalk10.dim("  \u2514" + "\u2500".repeat(67)));
+  console.log(chalk13.dim("  \u2514" + "\u2500".repeat(67)));
   let answer;
   try {
-    const chosen = await select8({
+    const chosen = await select11({
       message: " ",
       choices: [
         ...options.map((o) => ({ name: o, value: o })),
-        { name: chalk10.dim("Other (describe below)"), value: OTHER }
+        { name: chalk13.dim("Other (describe below)"), value: OTHER }
       ]
     });
     answer = chosen === OTHER ? await promptInput5({ message: "Your answer:" }) : chosen;
@@ -2588,6 +3416,8 @@ var toolModules = [
   reject_exports,
   accept_exports,
   edit_task_exports,
+  move_task_exports,
+  wiki_exports,
   // Low-level tools
   list_tasks_exports,
   get_task_exports,