@bretwardjames/ghp-core 0.2.0-beta.3 → 0.2.0-beta.5

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -22,54 +32,79 @@ var index_exports = {};
 __export(index_exports, {
   BranchLinker: () => BranchLinker,
   CLI_TO_VSCODE_MAP: () => CLI_TO_VSCODE_MAP,
+  ClaudeClient: () => ClaudeClient,
   DEFAULT_VALUES: () => DEFAULT_VALUES,
+  GHP_TOOLS: () => GHP_TOOLS,
   GitHubAPI: () => GitHubAPI,
   SETTING_DISPLAY_NAMES: () => SETTING_DISPLAY_NAMES,
   SYNCABLE_KEYS: () => SYNCABLE_KEYS,
+  SessionWatcher: () => SessionWatcher,
+  TOOL_NAMES: () => TOOL_NAMES,
   VSCODE_TO_CLI_MAP: () => VSCODE_TO_CLI_MAP,
   branchExists: () => branchExists,
+  buildConventionsContext: () => buildConventionsContext,
   buildIssueUrl: () => buildIssueUrl,
   buildOrgProjectUrl: () => buildOrgProjectUrl,
   buildProjectUrl: () => buildProjectUrl,
   buildPullRequestUrl: () => buildPullRequestUrl,
   buildRepoUrl: () => buildRepoUrl,
+  checkTmuxForPermission: () => checkTmuxForPermission,
   checkoutBranch: () => checkoutBranch,
+  claudePrompts: () => prompts_exports,
+  cleanupStaleAgents: () => cleanupStaleAgents,
   computeSettingsDiff: () => computeSettingsDiff,
   createBranch: () => createBranch,
+  createSessionWatcher: () => createSessionWatcher,
   createWorktree: () => createWorktree,
   detectRepository: () => detectRepository,
   extractIssueNumberFromBranch: () => extractIssueNumberFromBranch,
   fetchOrigin: () => fetchOrigin,
+  findSessionFile: () => findSessionFile,
+  formatAction: () => formatAction,
   formatConflict: () => formatConflict,
   generateBranchName: () => generateBranchName,
   generateWorktreePath: () => generateWorktreePath,
+  getAgent: () => getAgent,
+  getAgentByIssue: () => getAgentByIssue,
+  getAgentSummaries: () => getAgentSummaries,
   getAllBranches: () => getAllBranches,
   getCommitsAhead: () => getCommitsAhead,
   getCommitsBehind: () => getCommitsBehind,
   getCurrentBranch: () => getCurrentBranch,
   getDefaultBranch: () => getDefaultBranch,
   getDiffSummary: () => getDiffSummary,
+  getIssueReferenceText: () => getIssueReferenceText,
   getLocalBranches: () => getLocalBranches,
+  getRegistryPath: () => getRegistryPath,
   getRemoteBranches: () => getRemoteBranches,
   getRepositoryRoot: () => getRepositoryRoot,
+  getTools: () => getTools,
   getWorktreeForBranch: () => getWorktreeForBranch,
   hasDifferences: () => hasDifferences,
   hasUncommittedChanges: () => hasUncommittedChanges,
   isGitRepository: () => isGitRepository,
+  listAgents: () => listAgents,
   listWorktrees: () => listWorktrees,
+  loadProjectConventions: () => loadProjectConventions,
+  loadRegistry: () => loadRegistry,
   normalizeVSCodeSettings: () => normalizeVSCodeSettings,
   parseBranchLink: () => parseBranchLink,
   parseGitHubUrl: () => parseGitHubUrl,
   parseIssueUrl: () => parseIssueUrl,
+  parseSessionLine: () => parseSessionLine,
   pullLatest: () => pullLatest,
   queries: () => queries_exports,
+  registerAgent: () => registerAgent,
   removeBranchLinkFromBody: () => removeBranchLinkFromBody,
   removeWorktree: () => removeWorktree,
   resolveConflicts: () => resolveConflicts,
   sanitizeForBranchName: () => sanitizeForBranchName,
+  saveRegistry: () => saveRegistry,
   setBranchLinkInBody: () => setBranchLinkInBody,
   skip: () => skip,
   toVSCodeSettings: () => toVSCodeSettings,
+  unregisterAgent: () => unregisterAgent,
+  updateAgent: () => updateAgent,
   useCli: () => useCli,
   useCustom: () => useCustom,
   useVSCode: () => useVSCode,
@@ -85,6 +120,7 @@ var queries_exports = {};
 __export(queries_exports, {
   ADD_COMMENT_MUTATION: () => ADD_COMMENT_MUTATION,
   ADD_LABELS_MUTATION: () => ADD_LABELS_MUTATION,
+  ADD_SUB_ISSUE_MUTATION: () => ADD_SUB_ISSUE_MUTATION,
   ADD_TO_PROJECT_MUTATION: () => ADD_TO_PROJECT_MUTATION,
   COLLABORATORS_QUERY: () => COLLABORATORS_QUERY,
   CREATE_ISSUE_MUTATION: () => CREATE_ISSUE_MUTATION,
@@ -93,6 +129,7 @@ __export(queries_exports, {
   ISSUE_DETAILS_QUERY: () => ISSUE_DETAILS_QUERY,
   ISSUE_FOR_UPDATE_QUERY: () => ISSUE_FOR_UPDATE_QUERY,
   ISSUE_NODE_ID_QUERY: () => ISSUE_NODE_ID_QUERY,
+  ISSUE_RELATIONSHIPS_QUERY: () => ISSUE_RELATIONSHIPS_QUERY,
   ISSUE_TYPES_QUERY: () => ISSUE_TYPES_QUERY,
   LABEL_EXISTS_QUERY: () => LABEL_EXISTS_QUERY,
   PROJECT_FIELDS_QUERY: () => PROJECT_FIELDS_QUERY,
@@ -100,6 +137,7 @@ __export(queries_exports, {
   PROJECT_VIEWS_QUERY: () => PROJECT_VIEWS_QUERY,
   RECENT_ISSUES_QUERY: () => RECENT_ISSUES_QUERY,
   REMOVE_LABELS_MUTATION: () => REMOVE_LABELS_MUTATION,
+  REMOVE_SUB_ISSUE_MUTATION: () => REMOVE_SUB_ISSUE_MUTATION,
   REPOSITORY_ID_QUERY: () => REPOSITORY_ID_QUERY,
   REPOSITORY_PROJECTS_QUERY: () => REPOSITORY_PROJECTS_QUERY,
   UPDATE_ISSUE_BODY_MUTATION: () => UPDATE_ISSUE_BODY_MUTATION,
@@ -180,6 +218,8 @@ var PROJECT_ITEMS_QUERY = `
                                 assignees(first: 5) { nodes { login } }
                                 labels(first: 10) { nodes { name color } }
                                 repository { name }
+                                parent { id number title state }
+                                subIssues(first: 50) { nodes { id number title state } }
                             }
                             ... on PullRequest {
                                 title
@@ -468,6 +508,37 @@ var UPDATE_ISSUE_MUTATION = `
         }
     }
 `;
+var ADD_SUB_ISSUE_MUTATION = `
+    mutation($issueId: ID!, $subIssueId: ID!) {
+        addSubIssue(input: { issueId: $issueId, subIssueId: $subIssueId }) {
+            issue { id number title }
+            subIssue { id number title }
+        }
+    }
+`;
+var REMOVE_SUB_ISSUE_MUTATION = `
+    mutation($issueId: ID!, $subIssueId: ID!) {
+        removeSubIssue(input: { issueId: $issueId, subIssueId: $subIssueId }) {
+            issue { id number title }
+            subIssue { id number title }
+        }
+    }
+`;
+var ISSUE_RELATIONSHIPS_QUERY = `
+    query($owner: String!, $name: String!, $number: Int!) {
+        repository(owner: $owner, name: $name) {
+            issue(number: $number) {
+                id
+                number
+                title
+                parent { id number title state }
+                subIssues(first: 50) {
+                    nodes { id number title state }
+                }
+            }
+        }
+    }
+`;
 
 // src/github-api.ts
 function createAuthError(message, type, details) {
@@ -502,6 +573,7 @@ function checkAuthError(error) {
 }
 var GitHubAPI = class {
   graphqlWithAuth = null;
+  graphqlWithSubIssues = null;
   tokenProvider;
   onAuthError;
   username = null;
@@ -535,12 +607,19 @@ var GitHubAPI = class {
         authorization: `token ${token}`
       }
     });
+    this.graphqlWithSubIssues = import_graphql.graphql.defaults({
+      headers: {
+        authorization: `token ${token}`,
+        "GraphQL-Features": "sub_issues"
+      }
+    });
     try {
       const response = await this.graphqlWithAuth(VIEWER_QUERY);
       this.username = response.viewer.login;
       return true;
     } catch {
       this.graphqlWithAuth = null;
+      this.graphqlWithSubIssues = null;
       return false;
     }
   }
@@ -582,7 +661,7 @@ var GitHubAPI = class {
    * Get items from a project
    */
   async getProjectItems(projectId, projectTitle) {
-    if (!this.graphqlWithAuth) throw new Error("Not authenticated");
+    if (!this.graphqlWithSubIssues) throw new Error("Not authenticated");
     const statusField = await this.getStatusField(projectId);
     const statusOrderMap = /* @__PURE__ */ new Map();
     if (statusField) {
@@ -590,7 +669,7 @@ var GitHubAPI = class {
         statusOrderMap.set(opt.name.toLowerCase(), idx);
       });
     }
-    const response = await this.graphqlWithAuth(PROJECT_ITEMS_QUERY, { projectId });
+    const response = await this.graphqlWithSubIssues(PROJECT_ITEMS_QUERY, { projectId });
     return response.node.items.nodes.filter((item) => item.content).map((item) => {
       const content = item.content;
       const fields = {};
@@ -624,6 +703,8 @@ var GitHubAPI = class {
           state = "closed";
         }
       }
+      const parent = content.parent || null;
+      const subIssues = content.subIssues?.nodes || [];
       return {
         id: item.id,
         title: content.title || "Untitled",
@@ -639,7 +720,9 @@ var GitHubAPI = class {
         url: content.url || null,
         projectId,
         projectTitle,
-        fields
+        fields,
+        parent,
+        subIssues
       };
     });
   }
@@ -1097,6 +1180,101 @@ var GitHubAPI = class {
       return false;
     }
   }
+  // =========================================================================
+  // Sub-Issue / Parent-Child Relationships
+  // =========================================================================
+  /**
+   * Get the node ID for an issue
+   */
+  async getIssueNodeId(repo, issueNumber) {
+    if (!this.graphqlWithAuth) throw new Error("Not authenticated");
+    try {
+      const response = await this.graphqlWithAuth(ISSUE_FOR_UPDATE_QUERY, {
+        owner: repo.owner,
+        name: repo.name,
+        number: issueNumber
+      });
+      return response.repository.issue?.id ?? null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Add a sub-issue to a parent issue
+   * @param repo Repository info
+   * @param parentNumber Parent issue number
+   * @param childNumber Child issue number to add as sub-issue
+   * @returns true if successful
+   */
+  async addSubIssue(repo, parentNumber, childNumber) {
+    if (!this.graphqlWithSubIssues) throw new Error("Not authenticated");
+    try {
+      const [parentId, childId] = await Promise.all([
+        this.getIssueNodeId(repo, parentNumber),
+        this.getIssueNodeId(repo, childNumber)
+      ]);
+      if (!parentId || !childId) {
+        return false;
+      }
+      await this.graphqlWithSubIssues(ADD_SUB_ISSUE_MUTATION, {
+        issueId: parentId,
+        subIssueId: childId
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Remove a sub-issue from its parent issue
+   * @param repo Repository info
+   * @param parentNumber Parent issue number
+   * @param childNumber Child issue number to remove
+   * @returns true if successful
+   */
+  async removeSubIssue(repo, parentNumber, childNumber) {
+    if (!this.graphqlWithSubIssues) throw new Error("Not authenticated");
+    try {
+      const [parentId, childId] = await Promise.all([
+        this.getIssueNodeId(repo, parentNumber),
+        this.getIssueNodeId(repo, childNumber)
+      ]);
+      if (!parentId || !childId) {
+        return false;
+      }
+      await this.graphqlWithSubIssues(REMOVE_SUB_ISSUE_MUTATION, {
+        issueId: parentId,
+        subIssueId: childId
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get issue relationships (parent and sub-issues)
+   */
+  async getIssueRelationships(repo, issueNumber) {
+    if (!this.graphqlWithSubIssues) throw new Error("Not authenticated");
+    try {
+      const response = await this.graphqlWithSubIssues(ISSUE_RELATIONSHIPS_QUERY, {
+        owner: repo.owner,
+        name: repo.name,
+        number: issueNumber
+      });
+      const issue = response.repository.issue;
+      if (!issue) return null;
+      return {
+        id: issue.id,
+        number: issue.number,
+        title: issue.title,
+        parent: issue.parent,
+        subIssues: issue.subIssues.nodes
+      };
+    } catch {
+      return null;
+    }
+  }
 };
 
 // src/branch-linker.ts
@@ -1406,13 +1584,13 @@ async function getDefaultBranch(options = {}) {
   }
   return "master";
 }
-function validatePath(path) {
-  if (!path || path.trim().length === 0) {
+function validatePath(path2) {
+  if (!path2 || path2.trim().length === 0) {
     throw new Error("Path cannot be empty");
   }
   const dangerousChars = /[`$;|&<>(){}[\]'"\n\r]/;
-  if (dangerousChars.test(path)) {
-    throw new Error(`Path contains invalid characters: ${path}`);
+  if (dangerousChars.test(path2)) {
+    throw new Error(`Path contains invalid characters: ${path2}`);
   }
 }
 async function createWorktree(worktreePath, branch, options = {}) {
@@ -1652,58 +1830,1409 @@ function getDiffSummary(diff) {
   }
   return parts.join(", ");
 }
+
+// src/claude/client.ts
+var import_sdk = __toESM(require("@anthropic-ai/sdk"), 1);
+
+// src/claude/prompts/pr-description.ts
+var PR_DESCRIPTION_PROMPT = `You are a helpful assistant that generates clear, concise pull request descriptions.
+
+Given a git diff and optionally a linked issue and commit history, generate a PR description that:
+
+1. Summarizes what the PR does in 1-2 sentences
+2. Lists the key changes made
+3. Notes any breaking changes or migration steps needed
+4. References the linked issue if provided (following project conventions)
+
+Format the output as markdown suitable for a GitHub PR description.
+
+Guidelines:
+- Be concise but complete
+- Focus on the "why" not just the "what"
+- Use bullet points for lists of changes
+- Highlight any important decisions or trade-offs
+- If there are UI changes, note that screenshots may be needed
+- IMPORTANT: Follow any project-specific conventions provided (e.g., "Relates to" vs "Closes")
+
+Output format:
+## Summary
+[1-2 sentence summary]
+
+## Changes
+- [Change 1]
+- [Change 2]
+...
+
+## Notes
+[Any additional notes, breaking changes, or migration steps - omit if none]
+
+[Issue reference following project conventions]
+`;
+function buildPRDescriptionSystemPrompt(conventions) {
+  let prompt = PR_DESCRIPTION_PROMPT;
+  if (conventions) {
+    prompt += `
+
+## Project Conventions
+${conventions}
+`;
+  }
+  return prompt;
+}
+function buildPRDescriptionUserPrompt(options) {
+  let prompt = "## Git Diff\n```diff\n" + options.diff + "\n```\n\n";
+  if (options.issue) {
+    prompt += "## Linked Issue\n";
+    prompt += `**#${options.issue.number}: ${options.issue.title}**
+
+`;
+    prompt += options.issue.body + "\n\n";
+  }
+  if (options.commits && options.commits.length > 0) {
+    prompt += "## Recent Commits\n";
+    for (const commit of options.commits) {
+      prompt += `- ${commit}
+`;
+    }
+    prompt += "\n";
+  }
+  if (options.context) {
+    prompt += "## Additional Context\n" + options.context + "\n";
+  }
+  return prompt;
+}
+
+// src/claude/prompts/plan-epic.ts
+var PLAN_EPIC_SYSTEM_PROMPT = `You are an expert software project planner. Your job is to break down epics (large features) into well-structured, actionable GitHub issues.
+
+When planning an epic, you should:
+
+1. **Analyze the Epic**: Understand the scope and goals of the feature
+2. **Identify Components**: Break it into logical sub-tasks
+3. **Create Issues**: Generate issues that are:
+   - Small enough to complete in 1-3 days
+   - Independent where possible (minimize blocking dependencies)
+   - Clear with acceptance criteria
+   - Properly labeled and categorized
+
+4. **Structure Hierarchy**:
+   - Create a parent epic issue first
+   - Create child issues that link to the parent
+   - Set up any blocking dependencies
+
+Issue Structure Guidelines:
+- Title: Clear, action-oriented (e.g., "Add user authentication endpoint")
+- Body should include:
+  - ## Overview (1-2 sentences)
+  - ## Tasks (checkbox list of specific implementation tasks)
+  - ## Acceptance Criteria (what "done" looks like)
+  - ## Dependencies (if any)
+
+When you have tools available, use them to actually create the issues.
+When you don't have tools, output a structured plan in markdown format.
+
+Keep issues focused and atomic. It's better to have more small issues than fewer large ones.
+`;
+function buildPlanEpicUserPrompt(options) {
+  let prompt = `# Epic to Plan
+
+${options.title}
+
+`;
+  if (options.context) {
+    prompt += `## Project Context
+${options.context}
+
+`;
+  }
+  if (options.existingIssues && options.existingIssues.length > 0) {
+    prompt += "## Existing Issues in Project\n";
+    prompt += "Consider these existing issues to avoid duplication:\n\n";
+    for (const issue of options.existingIssues.slice(0, 20)) {
+      prompt += `- #${issue.number}: ${issue.title}
+`;
+    }
+    prompt += "\n";
+  }
+  prompt += `## Instructions
+`;
+  prompt += `Break down this epic into actionable issues. `;
+  prompt += `First create the parent epic issue, then create child issues for each component.
+
+`;
+  prompt += `Use the available tools to create issues if they are available, `;
+  prompt += `otherwise output a structured plan in markdown.
+`;
+  return prompt;
+}
+var EPIC_ISSUE_TEMPLATE = `## Overview
+
+{overview}
+
+## Sub-Issues
+
+This epic will be broken down into the following issues:
+
+{subissues}
+
+## Acceptance Criteria
+
+- [ ] All sub-issues completed
+- [ ] Integration tested
+- [ ] Documentation updated
+`;
+var CHILD_ISSUE_TEMPLATE = `## Overview
+
+{overview}
+
+Part of #{parent_number}
+
+## Tasks
+
+{tasks}
+
+## Acceptance Criteria
+
+{acceptance_criteria}
+
+## Dependencies
+
+{dependencies}
+`;
+
+// src/claude/prompts/expand-issue.ts
+var EXPAND_ISSUE_PROMPT = `You are a helpful assistant that expands brief issue descriptions into well-structured GitHub issues.
+
+Given a brief description, generate a complete issue with:
+1. A clear, action-oriented title
+2. A detailed description with context
+3. Acceptance criteria as a checklist
+4. Suggested labels (if applicable)
+
+Output your response as JSON with this structure:
+{
+  "title": "Clear action-oriented title",
+  "body": "Full markdown body with ## sections",
+  "labels": ["suggested", "labels"],
+  "assignees": []
+}
+
+Guidelines for the body:
+- Start with a brief ## Overview section (1-2 sentences)
+- Include ## Acceptance Criteria with checkbox items
+- Add ## Technical Notes if there are implementation considerations
+- Keep it concise but complete
+- Use markdown formatting appropriately
+
+Common labels to suggest based on content:
+- bug: for bug fixes
+- enhancement: for new features
+- documentation: for docs changes
+- refactor: for code cleanup
+- performance: for optimization work
+- security: for security-related issues
+- testing: for test-related issues
+
+Only output the JSON, no additional text.
+`;
+function buildExpandIssueUserPrompt(options) {
+  let prompt = `Brief: ${options.brief}
+
+`;
+  if (options.projectContext) {
+    prompt += `Project Context:
+${options.projectContext}
+
+`;
+  }
+  if (options.repoContext) {
+    prompt += `Repository Context:
+${options.repoContext}
+
+`;
+  }
+  if (options.existingLabels && options.existingLabels.length > 0) {
+    prompt += `Available Labels:
+${options.existingLabels.join(", ")}
+
+`;
+  }
+  return prompt;
+}
+
+// src/claude/tools.ts
+var CREATE_ISSUE_TOOL = {
+  name: "create_issue",
+  description: "Create a new GitHub issue in the repository. Returns the created issue number and URL.",
+  input_schema: {
+    type: "object",
+    properties: {
+      title: {
+        type: "string",
+        description: "The title of the issue. Should be clear and action-oriented."
+      },
+      body: {
+        type: "string",
+        description: "The body/description of the issue in markdown format."
+      },
+      labels: {
+        type: "array",
+        description: "Labels to apply to the issue.",
+        items: { type: "string" }
+      },
+      assignees: {
+        type: "array",
+        description: "GitHub usernames to assign to the issue.",
+        items: { type: "string" }
+      }
+    },
+    required: ["title", "body"]
+  }
+};
+var SET_PARENT_TOOL = {
+  name: "set_parent",
+  description: "Set a parent-child relationship between two issues. The child issue will be linked to the parent epic.",
+  input_schema: {
+    type: "object",
+    properties: {
+      child_number: {
+        type: "number",
+        description: "The issue number of the child issue."
+      },
+      parent_number: {
+        type: "number",
+        description: "The issue number of the parent epic."
+      }
+    },
+    required: ["child_number", "parent_number"]
+  }
+};
+var SET_FIELD_TOOL = {
+  name: "set_field",
+  description: "Set a project field value on an issue (e.g., Status, Priority, Size).",
+  input_schema: {
+    type: "object",
+    properties: {
+      issue_number: {
+        type: "number",
+        description: "The issue number to update."
+      },
+      field_name: {
+        type: "string",
+        description: 'The name of the field to set (e.g., "Status", "Priority").'
+      },
+      value: {
+        type: "string",
+        description: "The value to set for the field."
+      }
+    },
+    required: ["issue_number", "field_name", "value"]
+  }
+};
+var ADD_BLOCKER_TOOL = {
+  name: "add_blocker",
+  description: "Add a blocking dependency between issues. The blocker must be completed before the blocked issue.",
+  input_schema: {
+    type: "object",
+    properties: {
+      blocked_issue: {
+        type: "number",
+        description: "The issue number that is blocked."
+      },
+      blocking_issue: {
+        type: "number",
+        description: "The issue number that is blocking."
+      }
+    },
+    required: ["blocked_issue", "blocking_issue"]
+  }
+};
+var ADD_TO_PROJECT_TOOL = {
+  name: "add_to_project",
+  description: "Add an issue to a GitHub Project board.",
+  input_schema: {
+    type: "object",
+    properties: {
+      issue_number: {
+        type: "number",
+        description: "The issue number to add to the project."
+      },
+      project_name: {
+        type: "string",
+        description: "The name of the project to add the issue to."
+      }
+    },
+    required: ["issue_number"]
+  }
+};
+var ADD_LABELS_TOOL = {
+  name: "add_labels",
+  description: "Add labels to an existing issue.",
+  input_schema: {
+    type: "object",
+    properties: {
+      issue_number: {
+        type: "number",
+        description: "The issue number to add labels to."
+      },
+      labels: {
+        type: "array",
+        description: "The labels to add.",
+        items: { type: "string" }
+      }
+    },
+    required: ["issue_number", "labels"]
+  }
+};
+var GHP_TOOLS = [
+  CREATE_ISSUE_TOOL,
+  SET_PARENT_TOOL,
+  SET_FIELD_TOOL,
+  ADD_BLOCKER_TOOL,
+  ADD_TO_PROJECT_TOOL,
+  ADD_LABELS_TOOL
+];
+function getTools(names) {
+  return GHP_TOOLS.filter((tool) => names.includes(tool.name));
+}
+var TOOL_NAMES = {
+  CREATE_ISSUE: "create_issue",
+  SET_PARENT: "set_parent",
+  SET_FIELD: "set_field",
+  ADD_BLOCKER: "add_blocker",
+  ADD_TO_PROJECT: "add_to_project",
+  ADD_LABELS: "add_labels"
+};
+
+// src/claude/client.ts
+var DEFAULT_MODEL = "claude-sonnet-4-20250514";
+var DEFAULT_MAX_TOKENS = 4096;
+var ClaudeClient = class {
+  client = null;
+  options;
+  config;
+  constructor(options) {
+    this.options = options;
+    this.config = {
+      model: options.model || DEFAULT_MODEL,
+      maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS
+    };
+  }
+  /**
+   * Initialize the client with an API key
+   */
+  async ensureClient() {
+    if (this.client) {
+      return this.client;
+    }
+    let apiKey = this.options.apiKey;
+    if (!apiKey && this.options.apiKeyProvider) {
+      apiKey = await this.options.apiKeyProvider.getApiKey() ?? void 0;
+    }
+    if (!apiKey) {
+      throw new Error(
+        "No API key provided. Set ANTHROPIC_API_KEY environment variable, pass apiKey option, or provide an apiKeyProvider."
+      );
+    }
+    this.client = new import_sdk.default({ apiKey });
+    return this.client;
+  }
+  /**
+   * Get the current model configuration
+   */
+  get model() {
+    return this.config.model;
+  }
+  /**
+   * Get the current max tokens configuration
+   */
+  get maxTokens() {
+    return this.config.maxTokens;
+  }
+  // =========================================================================
+  // Low-Level API
+  // =========================================================================
+  /**
+   * Send a message to Claude and get a response.
+   * This is the low-level API for custom prompts.
+   */
+  async complete(options) {
+    const client = await this.ensureClient();
+    const maxTokens = options.maxTokens || this.config.maxTokens;
+    const messages = options.messages.map((m) => ({
+      role: m.role,
+      content: m.content
+    }));
+    let text = "";
+    const toolCalls = [];
+    let usage = { input_tokens: 0, output_tokens: 0, total_tokens: 0 };
+    let stopReason = "end_turn";
+    if (options.callbacks?.onToken || options.callbacks?.onToolCall) {
+      const stream = await client.messages.stream({
+        model: this.config.model,
+        max_tokens: maxTokens,
+        system: options.system,
+        messages,
+        tools: options.tools
+      });
+      for await (const event of stream) {
+        if (event.type === "content_block_delta") {
+          const delta = event.delta;
+          if ("text" in delta && delta.text) {
+            text += delta.text;
+            options.callbacks?.onToken?.(delta.text);
+          }
+        } else if (event.type === "message_stop") {
+        } else if (event.type === "message_delta") {
+          if (event.usage) {
+            usage.output_tokens = event.usage.output_tokens;
+          }
+        }
+      }
+      const finalMessage = await stream.finalMessage();
+      usage.input_tokens = finalMessage.usage.input_tokens;
+      usage.output_tokens = finalMessage.usage.output_tokens;
+      usage.total_tokens = usage.input_tokens + usage.output_tokens;
+      stopReason = finalMessage.stop_reason;
+      for (const block of finalMessage.content) {
+        if (block.type === "tool_use") {
+          toolCalls.push({
+            name: block.name,
+            input: block.input
+          });
+        }
+      }
+    } else {
+      const response = await client.messages.create({
+        model: this.config.model,
+        max_tokens: maxTokens,
+        system: options.system,
+        messages,
+        tools: options.tools
+      });
+      usage = {
+        input_tokens: response.usage.input_tokens,
+        output_tokens: response.usage.output_tokens,
+        total_tokens: response.usage.input_tokens + response.usage.output_tokens
+      };
+      stopReason = response.stop_reason;
+      for (const block of response.content) {
+        if (block.type === "text") {
+          text += block.text;
+        } else if (block.type === "tool_use") {
+          toolCalls.push({
+            name: block.name,
+            input: block.input
+          });
+        }
+      }
+    }
+    if (toolCalls.length > 0 && options.toolHandlers) {
+      for (const toolCall of toolCalls) {
+        const handler = options.toolHandlers[toolCall.name];
+        if (handler) {
+          options.callbacks?.onToolCall?.(toolCall.name, toolCall.input);
+          try {
+            const result = await handler(toolCall.input, options.toolContext || {});
+            toolCall.result = result;
+            options.callbacks?.onToolResult?.(toolCall.name, result);
+          } catch (error) {
+            toolCall.result = { error: error instanceof Error ? error.message : "Unknown error" };
+            options.callbacks?.onToolResult?.(toolCall.name, toolCall.result);
+          }
+        }
+      }
+    }
+    return { text, toolCalls, usage, stopReason };
+  }
+  /**
+   * Run a multi-turn conversation with tool use until completion.
+   * Handles the tool use loop automatically.
+   */
+  async runWithTools(options) {
+    const maxTurns = options.maxTurns || 10;
+    const messages = [
+      { role: "user", content: options.initialMessage }
+    ];
+    let totalUsage = { input_tokens: 0, output_tokens: 0, total_tokens: 0 };
+    const allToolCalls = [];
+    let finalText = "";
+    let turn = 0;
+    while (turn < maxTurns) {
+      turn++;
+      const result = await this.complete({
+        system: options.system,
+        messages,
+        tools: options.tools,
+        toolHandlers: options.toolHandlers,
+        toolContext: options.toolContext,
+        maxTokens: options.maxTokens,
+        callbacks: options.callbacks
+      });
+      totalUsage.input_tokens += result.usage.input_tokens;
+      totalUsage.output_tokens += result.usage.output_tokens;
+      totalUsage.total_tokens += result.usage.total_tokens;
+      if (result.toolCalls.length === 0 || result.stopReason !== "tool_use") {
+        finalText = result.text;
+        break;
+      }
+      const assistantContent = [];
+      if (result.text) {
+        assistantContent.push({ type: "text", text: result.text });
+      }
+      for (const tc of result.toolCalls) {
+        assistantContent.push({
+          type: "tool_use",
+          id: `tool_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+          name: tc.name,
+          input: tc.input
+        });
+        allToolCalls.push(tc);
+      }
+      messages.push({ role: "assistant", content: assistantContent });
+      const toolResults = result.toolCalls.map((tc, i) => ({
+        type: "tool_result",
+        tool_use_id: assistantContent[assistantContent.length - result.toolCalls.length + i].id,
+        content: JSON.stringify(tc.result ?? { success: true })
+      }));
+      messages.push({ role: "user", content: toolResults });
+    }
+    return {
+      text: finalText,
+      toolCalls: allToolCalls,
+      usage: totalUsage,
+      stopReason: "end_turn"
+    };
+  }
+  // =========================================================================
+  // High-Level API
+  // =========================================================================
+  /**
+   * Generate a PR description from a diff and optional issue context.
+   */
+  async generatePRDescription(options) {
+    const userMessage = this.buildPRDescriptionPrompt(options);
+    const systemPrompt = buildPRDescriptionSystemPrompt(options.conventions);
+    const result = await this.complete({
+      system: systemPrompt,
+      messages: [{ role: "user", content: userMessage }]
+    });
+    return result.text;
+  }
+  buildPRDescriptionPrompt(options) {
+    let prompt = "## Git Diff\n```diff\n" + options.diff + "\n```\n\n";
+    if (options.issue) {
+      prompt += "## Linked Issue\n";
+      prompt += `**#${options.issue.number}: ${options.issue.title}**
+
+`;
+      prompt += options.issue.body + "\n\n";
+    }
+    if (options.feedback) {
+      prompt += "## User Feedback\n";
+      prompt += "Please regenerate the PR description taking this feedback into account:\n";
+      prompt += options.feedback + "\n\n";
+    }
+    if (options.commits && options.commits.length > 0) {
+      prompt += "## Recent Commits\n";
+      for (const commit of options.commits) {
+        prompt += `- ${commit}
+`;
+      }
+      prompt += "\n";
+    }
+    if (options.context) {
+      prompt += "## Additional Context\n" + options.context + "\n";
+    }
+    return prompt;
+  }
+  /**
+   * Plan an epic by breaking it down into issues.
+   * Can use tools to actually create the issues.
+   */
+  async planEpic(options) {
+    const userMessage = buildPlanEpicUserPrompt(options);
+    const createdIssues = [];
+    const wrappedHandlers = {};
+    if (options.tools) {
+      for (const [name, handler] of Object.entries(options.tools)) {
+        wrappedHandlers[name] = async (input, context) => {
+          const result2 = await handler(input, context);
+          if (name === "create_issue" && result2 && typeof result2 === "object") {
+            const issueResult = result2;
+            if (issueResult.number) {
+              createdIssues.push({
+                number: issueResult.number,
+                title: issueResult.title || input.title
+              });
+            }
+          }
+          return result2;
+        };
+      }
+    }
+    const result = await this.runWithTools({
+      system: PLAN_EPIC_SYSTEM_PROMPT,
+      initialMessage: userMessage,
+      tools: GHP_TOOLS,
+      toolHandlers: wrappedHandlers,
+      toolContext: options.tools ? {} : void 0,
+      callbacks: options.callbacks
+    });
+    return {
+      ...result,
+      createdIssues
+    };
+  }
+  /**
+   * Expand a brief issue description into a full issue with acceptance criteria.
+   */
+  async expandIssue(options) {
+    let prompt = `Brief: ${options.brief}
+
+`;
+    if (options.projectContext) {
+      prompt += `Project Context:
+${options.projectContext}
+
+`;
+    }
+    if (options.repoContext) {
+      prompt += `Repository Context:
+${options.repoContext}
+
+`;
+    }
+    const result = await this.complete({
+      system: EXPAND_ISSUE_PROMPT,
+      messages: [{ role: "user", content: prompt }]
+    });
+    try {
+      const parsed = JSON.parse(result.text);
+      return {
+        title: parsed.title || options.brief,
+        body: parsed.body || result.text,
+        suggestedLabels: parsed.labels,
+        suggestedAssignees: parsed.assignees
+      };
+    } catch {
+      return {
+        title: options.brief,
+        body: result.text
+      };
+    }
+  }
+};
+
+// src/claude/prompts/index.ts
+var prompts_exports = {};
+__export(prompts_exports, {
+  CHILD_ISSUE_TEMPLATE: () => CHILD_ISSUE_TEMPLATE,
+  EPIC_ISSUE_TEMPLATE: () => EPIC_ISSUE_TEMPLATE,
+  EXPAND_ISSUE_PROMPT: () => EXPAND_ISSUE_PROMPT,
+  PLAN_EPIC_SYSTEM_PROMPT: () => PLAN_EPIC_SYSTEM_PROMPT,
+  PR_DESCRIPTION_PROMPT: () => PR_DESCRIPTION_PROMPT,
+  buildExpandIssueUserPrompt: () => buildExpandIssueUserPrompt,
+  buildPRDescriptionSystemPrompt: () => buildPRDescriptionSystemPrompt,
+  buildPRDescriptionUserPrompt: () => buildPRDescriptionUserPrompt,
+  buildPlanEpicUserPrompt: () => buildPlanEpicUserPrompt
+});
+
+// src/conventions.ts
+var import_fs = require("fs");
+var import_path = require("path");
+function extractIssueReferenceConvention(content) {
+  const lowerContent = content.toLowerCase();
+  if (lowerContent.includes("relates to") && lowerContent.includes("not") && (lowerContent.includes("closes") || lowerContent.includes("fixes"))) {
+    return "relates";
+  }
+  if (lowerContent.includes('use "closes"') || lowerContent.includes("use 'closes'")) {
+    return "closes";
+  }
+  if (lowerContent.includes('use "fixes"') || lowerContent.includes("use 'fixes'")) {
+    return "fixes";
+  }
+  const relatesMatch = content.match(/relates to #\d+/i);
+  const closesMatch = content.match(/closes #\d+/i);
+  const fixesMatch = content.match(/fixes #\d+/i);
+  if (relatesMatch && !closesMatch && !fixesMatch) {
+    return "relates";
+  }
+  return null;
+}
+function extractCoAuthorFormat(content) {
+  const match = content.match(/Co-Authored-By:\s*[^\n]+/i);
+  if (match) {
+    return match[0];
+  }
+  return null;
+}
+function loadProjectConventions(repoRoot) {
+  let claudeMd = null;
+  try {
+    const claudeMdPath = (0, import_path.join)(repoRoot, "CLAUDE.md");
+    if ((0, import_fs.existsSync)(claudeMdPath)) {
+      claudeMd = (0, import_fs.readFileSync)(claudeMdPath, "utf-8");
+    }
+  } catch {
+  }
+  const conventions = {
+    claudeMd,
+    pr: {
+      issueReference: null,
+      coAuthorFormat: null,
+      titleFormat: null,
+      bodyFormat: null
+    },
+    commit: {
+      format: null,
+      coAuthorFormat: null
+    },
+    issue: {
+      titleFormat: null,
+      bodyStructure: null
+    }
+  };
+  if (claudeMd) {
+    conventions.pr.issueReference = extractIssueReferenceConvention(claudeMd);
+    conventions.pr.coAuthorFormat = extractCoAuthorFormat(claudeMd);
+    conventions.commit.coAuthorFormat = conventions.pr.coAuthorFormat;
+    const commitSection = claudeMd.match(/## Commit Messages?\s*\n([\s\S]*?)(?=\n##|\n$|$)/i);
+    if (commitSection) {
+      conventions.commit.format = commitSection[1].trim();
+    }
+  }
+  return conventions;
+}
+function buildConventionsContext(conventions) {
+  const parts = [];
+  if (conventions.pr.issueReference) {
+    const refMap = {
+      "relates": 'Use "Relates to #XX" (not "Closes" or "Fixes") unless the PR actually closes the issue',
+      "closes": 'Use "Closes #XX" to reference issues',
+      "fixes": 'Use "Fixes #XX" to reference issues'
+    };
+    parts.push(`Issue References: ${refMap[conventions.pr.issueReference]}`);
+  }
+  if (conventions.pr.coAuthorFormat) {
+    parts.push(`Co-Author Format: ${conventions.pr.coAuthorFormat}`);
+  }
+  if (conventions.commit.format) {
+    parts.push(`Commit Format:
+${conventions.commit.format}`);
+  }
+  if (parts.length === 0 && conventions.claudeMd) {
+    const relevantSections = conventions.claudeMd.split("\n").filter(
+      (line) => line.toLowerCase().includes("commit") || line.toLowerCase().includes("pr") || line.toLowerCase().includes("pull request") || line.toLowerCase().includes("issue") || line.toLowerCase().includes("relates") || line.toLowerCase().includes("closes")
+    ).slice(0, 20).join("\n");
+    if (relevantSections) {
+      parts.push(`Project Guidelines:
+${relevantSections}`);
+    }
+  }
+  return parts.join("\n\n");
+}
+function getIssueReferenceText(issueNumber, conventions, actuallyCloses = false) {
+  if (actuallyCloses) {
+    if (conventions.pr.issueReference === "fixes") {
+      return `Fixes #${issueNumber}`;
+    }
+    return `Closes #${issueNumber}`;
+  }
+  switch (conventions.pr.issueReference) {
+    case "relates":
+      return `Relates to #${issueNumber}`;
+    case "closes":
+      return `Closes #${issueNumber}`;
+    case "fixes":
+      return `Fixes #${issueNumber}`;
+    default:
+      return `Relates to #${issueNumber}`;
+  }
+}
+
+// src/agents/registry.ts
+var import_fs2 = require("fs");
+var import_os2 = require("os");
+var import_path2 = require("path");
+var import_crypto = require("crypto");
+var REGISTRY_VERSION = 1;
+function getRegistryPath() {
+  return (0, import_path2.join)((0, import_os2.homedir)(), ".ghp", "agents.json");
+}
+function loadRegistry() {
+  const path2 = getRegistryPath();
+  if (!(0, import_fs2.existsSync)(path2)) {
+    return {
+      version: REGISTRY_VERSION,
+      agents: {},
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  try {
+    const content = (0, import_fs2.readFileSync)(path2, "utf-8");
+    const registry = JSON.parse(content);
+    if (registry.version !== REGISTRY_VERSION) {
+      registry.version = REGISTRY_VERSION;
+    }
+    return registry;
+  } catch (error) {
+    console.error("Warning: Could not parse agents.json, starting fresh");
+    return {
+      version: REGISTRY_VERSION,
+      agents: {},
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+}
+function saveRegistry(registry) {
+  const path2 = getRegistryPath();
+  const dir = (0, import_path2.dirname)(path2);
+  if (!(0, import_fs2.existsSync)(dir)) {
+    (0, import_fs2.mkdirSync)(dir, { recursive: true });
+  }
+  registry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  (0, import_fs2.writeFileSync)(path2, JSON.stringify(registry, null, 2));
+}
+function registerAgent(options) {
+  const registry = loadRegistry();
+  const agent = {
+    id: (0, import_crypto.randomUUID)(),
+    issueNumber: options.issueNumber,
+    issueTitle: options.issueTitle,
+    pid: options.pid,
+    port: options.port,
+    worktreePath: options.worktreePath,
+    branch: options.branch,
+    status: "starting",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  registry.agents[agent.id] = agent;
+  saveRegistry(registry);
+  return agent;
+}
+function updateAgent(id, options) {
+  const registry = loadRegistry();
+  const agent = registry.agents[id];
+  if (!agent) {
+    return null;
+  }
+  if (options.status !== void 0) {
+    agent.status = options.status;
+  }
+  if (options.port !== void 0) {
+    agent.port = options.port;
+  }
+  if (options.error !== void 0) {
+    agent.error = options.error;
+  }
+  if (options.currentAction !== void 0) {
+    agent.currentAction = options.currentAction;
+  }
+  if (options.waitingForInput !== void 0) {
+    agent.waitingForInput = options.waitingForInput;
+  }
+  agent.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+  saveRegistry(registry);
+  return agent;
+}
+function unregisterAgent(id) {
+  const registry = loadRegistry();
+  if (!registry.agents[id]) {
+    return false;
+  }
+  delete registry.agents[id];
+  saveRegistry(registry);
+  return true;
+}
+function getAgent(id) {
+  const registry = loadRegistry();
+  return registry.agents[id] || null;
+}
+function getAgentByIssue(issueNumber) {
+  const registry = loadRegistry();
+  for (const agent of Object.values(registry.agents)) {
+    if (agent.issueNumber === issueNumber) {
+      return agent;
+    }
+  }
+  return null;
+}
+function listAgents() {
+  const registry = loadRegistry();
+  return Object.values(registry.agents);
+}
+function formatUptime(startedAt) {
+  const start = new Date(startedAt).getTime();
+  const now = Date.now();
+  const diffMs = now - start;
+  const seconds = Math.floor(diffMs / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) {
+    return `${days}d ${hours % 24}h`;
+  }
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`;
+  }
+  return `${seconds}s`;
+}
+function getAgentSummaries() {
+  const agents = listAgents();
+  return agents.map((agent) => ({
+    id: agent.id,
+    issueNumber: agent.issueNumber,
+    issueTitle: agent.issueTitle,
+    status: agent.status,
+    port: agent.port,
+    branch: agent.branch,
+    uptime: formatUptime(agent.startedAt),
+    currentAction: agent.currentAction,
+    waitingForInput: agent.waitingForInput
+  }));
+}
+function cleanupStaleAgents() {
+  return 0;
+}
+
+// src/agents/session-watcher.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var os = __toESM(require("os"), 1);
+var import_events = require("events");
+var import_child_process2 = require("child_process");
+var import_util2 = require("util");
+var execAsync2 = (0, import_util2.promisify)(import_child_process2.exec);
+function pathToClaudeProjectName(dirPath) {
+  return dirPath.replace(/\//g, "-").replace(/-\./g, "--");
+}
+async function findSessionFile(worktreePath) {
+  const claudeProjectsDir = path.join(os.homedir(), ".claude", "projects");
+  const projectName = pathToClaudeProjectName(worktreePath);
+  const projectDir = path.join(claudeProjectsDir, projectName);
+  try {
+    const files = await fs.promises.readdir(projectDir);
+    const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
+    if (jsonlFiles.length === 0) return null;
+    let mostRecent = null;
+    for (const file of jsonlFiles) {
+      const filePath = path.join(projectDir, file);
+      const stat = await fs.promises.stat(filePath);
+      if (!mostRecent || stat.mtimeMs > mostRecent.mtime) {
+        mostRecent = { file: filePath, mtime: stat.mtimeMs };
+      }
+    }
+    return mostRecent?.file || null;
+  } catch {
+    return null;
+  }
+}
+function parseSessionLine(line) {
+  try {
+    const entry = JSON.parse(line);
+    const timestamp = new Date(entry.timestamp || Date.now());
+    if (entry.type === "progress" && entry.data?.message) {
+      const innerMessage = entry.data.message;
+      const messageType = innerMessage.type;
+      const messageContent = innerMessage.message?.content;
+      if (messageType === "assistant" && messageContent) {
+        for (const block of messageContent) {
+          if (block.type === "tool_use") {
+            return {
+              type: "tool_start",
+              timestamp,
+              toolName: block.name,
+              toolInput: block.input
+            };
+          }
+          if (block.type === "text" && block.text) {
+            return {
+              type: "text",
+              timestamp,
+              text: block.text
+            };
+          }
+          if (block.type === "thinking") {
+            return {
+              type: "thinking",
+              timestamp,
+              text: block.thinking
+            };
+          }
+        }
+      }
+      if (messageType === "user" && messageContent) {
+        for (const block of messageContent) {
+          if (block.type === "tool_result") {
+            if (typeof block.content === "string" && block.content.includes("rejected")) {
+              return {
+                type: "user_input",
+                timestamp,
+                interrupted: true
+              };
+            }
+            return {
+              type: "tool_end",
+              timestamp,
+              interrupted: false
+            };
+          }
+        }
+      }
+    }
+    if (entry.type === "assistant" && entry.message?.content) {
+      for (const block of entry.message.content) {
+        if (block.type === "tool_use") {
+          return {
+            type: "tool_start",
+            timestamp,
+            toolName: block.name,
+            toolInput: block.input
+          };
+        }
+        if (block.type === "text" && block.text) {
+          return {
+            type: "text",
+            timestamp,
+            text: block.text
+          };
+        }
+        if (block.type === "thinking") {
+          return {
+            type: "thinking",
+            timestamp,
+            text: block.thinking
+          };
+        }
+      }
+    }
+    if (entry.type === "user" && entry.toolUseResult !== void 0) {
+      return {
+        type: "tool_end",
+        timestamp,
+        interrupted: entry.toolUseResult?.interrupted === true,
+        error: entry.toolUseResult?.is_error ? "Tool execution failed" : void 0
+      };
+    }
+    if (entry.type === "user" && entry.message?.content) {
+      const content = entry.message.content;
+      for (const block of content) {
+        if (block.type === "tool_result" && block.content?.includes?.("rejected")) {
+          return {
+            type: "user_input",
+            timestamp,
+            interrupted: true
+          };
+        }
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function formatAction(toolName, toolInput) {
+  switch (toolName) {
+    case "Read":
+      return `Reading ${toolInput?.file_path || "file"}`;
+    case "Write":
+      return `Writing ${toolInput?.file_path || "file"}`;
+    case "Edit":
+      return `Editing ${toolInput?.file_path || "file"}`;
+    case "Bash":
+      const cmd = toolInput?.command;
+      if (cmd) {
+        const shortCmd = cmd.length > 40 ? cmd.substring(0, 37) + "..." : cmd;
+        return `Running: ${shortCmd}`;
+      }
+      return "Running command";
+    case "Grep":
+      return `Searching for "${toolInput?.pattern || "pattern"}"`;
+    case "Glob":
+      return `Finding files: ${toolInput?.pattern || "pattern"}`;
+    case "WebFetch":
+      return `Fetching ${toolInput?.url || "URL"}`;
+    case "WebSearch":
+      return `Searching: ${toolInput?.query || "query"}`;
+    case "Task":
+      return `Spawning agent: ${toolInput?.description || "task"}`;
+    default:
+      return `Using ${toolName}`;
+  }
+}
+async function checkTmuxForPermission(windowName) {
+  try {
+    if (!/^[a-zA-Z0-9_-]+$/.test(windowName)) {
+      return null;
+    }
+    const { stdout } = await execAsync2(`tmux capture-pane -t "${windowName}" -p -S -50 2>/dev/null`);
+    if (!stdout.includes("Do you want to proceed?")) {
+      return null;
+    }
+    let toolName = "Unknown tool";
+    let description;
+    const mcpMatch = stdout.match(/Tool use\s*\n\s*\n\s*([^\n(]+)\(/);
+    if (mcpMatch) {
+      toolName = mcpMatch[1].trim().replace(/\s*\(MCP\)\s*$/, "");
+      const argsMatch = stdout.match(/Tool use\s*\n\s*\n\s*[^\n(]+\(([^)]*)\)/);
+      description = argsMatch ? argsMatch[1].substring(0, 40) : void 0;
+    }
+    if (toolName === "Unknown tool") {
+      const bashMatch = stdout.match(/Bash command[^\n]*\n\s*\n\s*([^\n]+)/);
+      if (bashMatch) {
+        toolName = "Bash";
+        description = bashMatch[1].trim().substring(0, 40);
+      }
+    }
+    if (toolName === "Unknown tool") {
+      const simpleMatch = stdout.match(/●\s*([A-Za-z]+)\s*\(/);
+      if (simpleMatch) {
+        toolName = simpleMatch[1];
+      }
+    }
+    return { toolName, description };
+  } catch {
+    return null;
+  }
+}
+var SessionWatcher = class extends import_events.EventEmitter {
+  filePath;
+  watcher = null;
+  position = 0;
+  status;
+  isWatching = false;
+  isReading = false;
+  tmuxWindow = null;
+  tmuxPollInterval = null;
+  constructor(sessionFilePath, tmuxWindowName) {
+    super();
+    this.filePath = sessionFilePath;
+    this.tmuxWindow = tmuxWindowName || null;
+    this.status = {
+      waitingForInput: false,
+      lastActivity: /* @__PURE__ */ new Date(),
+      recentEvents: []
+    };
+  }
+  /**
+   * Get current status
+   */
+  getStatus() {
+    return {
+      ...this.status,
+      recentEvents: [...this.status.recentEvents]
+    };
+  }
+  /**
+   * Start watching the session file
+   */
+  async start() {
+    if (this.isWatching) return;
+    try {
+      const stat = await fs.promises.stat(this.filePath);
+      this.position = stat.size;
+      this.watcher = fs.watch(this.filePath, async (eventType) => {
+        if (eventType === "change") {
+          await this.readNewLines();
+        }
+      });
+      if (this.tmuxWindow) {
+        this.startTmuxPolling();
+      }
+      this.isWatching = true;
+      this.emit("started");
+    } catch (error) {
+      this.emit("error", error);
+    }
+  }
+  /**
+   * Stop watching
+   */
+  stop() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    if (this.tmuxPollInterval) {
+      clearInterval(this.tmuxPollInterval);
+      this.tmuxPollInterval = null;
+    }
+    this.isWatching = false;
+    this.emit("stopped");
+  }
+  /**
+   * Start polling tmux for permission prompts
+   */
+  startTmuxPolling() {
+    this.tmuxPollInterval = setInterval(async () => {
+      if (!this.tmuxWindow) return;
+      const prompt = await checkTmuxForPermission(this.tmuxWindow);
+      if (prompt && !this.status.waitingForInput) {
+        this.status.waitingForInput = true;
+        this.status.currentAction = `Waiting: ${prompt.toolName}`;
+        this.status.currentTool = prompt.toolName;
+        this.emit("permission", prompt);
+        this.emit("status", this.getStatus());
+      } else if (!prompt && this.status.waitingForInput) {
+        this.status.waitingForInput = false;
+        this.emit("status", this.getStatus());
+      }
+    }, 2e3);
+  }
+  /**
+   * Read new lines from the file
+   */
+  async readNewLines() {
+    if (this.isReading) return;
+    this.isReading = true;
+    try {
+      const handle = await fs.promises.open(this.filePath, "r");
+      const stat = await handle.stat();
+      if (stat.size <= this.position) {
+        await handle.close();
+        return;
+      }
+      const buffer = Buffer.alloc(stat.size - this.position);
+      await handle.read(buffer, 0, buffer.length, this.position);
+      await handle.close();
+      this.position = stat.size;
+      const content = buffer.toString("utf-8");
+      const lines = content.split("\n").filter((l) => l.trim());
+      for (const line of lines) {
+        const event = parseSessionLine(line);
+        if (event) {
+          this.processEvent(event);
+        }
+      }
+    } catch (error) {
+      this.emit("error", error);
+    } finally {
+      this.isReading = false;
+    }
+  }
+  /**
+   * Process a parsed event and update status
+   */
+  processEvent(event) {
+    this.status.lastActivity = event.timestamp;
+    this.status.recentEvents.push(event);
+    if (this.status.recentEvents.length > 10) {
+      this.status.recentEvents.shift();
+    }
+    switch (event.type) {
+      case "tool_start":
+        this.status.currentTool = event.toolName;
+        this.status.currentAction = formatAction(event.toolName, event.toolInput);
+        this.status.waitingForInput = false;
+        break;
+      case "tool_end":
+        if (event.interrupted) {
+          this.status.waitingForInput = true;
+          this.status.currentAction = "Waiting for approval";
+        } else {
+          this.status.currentTool = void 0;
+          this.status.currentAction = void 0;
+        }
+        break;
+      case "user_input":
+        if (event.interrupted) {
+          this.status.waitingForInput = true;
+          this.status.currentAction = "Action rejected";
+        }
+        break;
+      case "text":
+        break;
+    }
+    this.emit("event", event);
+    this.emit("status", this.getStatus());
+  }
+};
+async function createSessionWatcher(worktreePath, tmuxWindowName) {
+  const sessionFile = await findSessionFile(worktreePath);
+  if (!sessionFile) return null;
+  return new SessionWatcher(sessionFile, tmuxWindowName);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BranchLinker,
   CLI_TO_VSCODE_MAP,
+  ClaudeClient,
   DEFAULT_VALUES,
+  GHP_TOOLS,
   GitHubAPI,
   SETTING_DISPLAY_NAMES,
   SYNCABLE_KEYS,
+  SessionWatcher,
+  TOOL_NAMES,
   VSCODE_TO_CLI_MAP,
   branchExists,
+  buildConventionsContext,
   buildIssueUrl,
   buildOrgProjectUrl,
   buildProjectUrl,
   buildPullRequestUrl,
   buildRepoUrl,
+  checkTmuxForPermission,
   checkoutBranch,
+  claudePrompts,
+  cleanupStaleAgents,
   computeSettingsDiff,
   createBranch,
+  createSessionWatcher,
   createWorktree,
   detectRepository,
   extractIssueNumberFromBranch,
   fetchOrigin,
+  findSessionFile,
+  formatAction,
   formatConflict,
   generateBranchName,
   generateWorktreePath,
+  getAgent,
+  getAgentByIssue,
+  getAgentSummaries,
   getAllBranches,
   getCommitsAhead,
   getCommitsBehind,
   getCurrentBranch,
   getDefaultBranch,
   getDiffSummary,
+  getIssueReferenceText,
   getLocalBranches,
+  getRegistryPath,
   getRemoteBranches,
   getRepositoryRoot,
+  getTools,
   getWorktreeForBranch,
   hasDifferences,
   hasUncommittedChanges,
   isGitRepository,
+  listAgents,
   listWorktrees,
+  loadProjectConventions,
+  loadRegistry,
   normalizeVSCodeSettings,
   parseBranchLink,
   parseGitHubUrl,
   parseIssueUrl,
+  parseSessionLine,
   pullLatest,
   queries,
+  registerAgent,
   removeBranchLinkFromBody,
   removeWorktree,
   resolveConflicts,
   sanitizeForBranchName,
+  saveRegistry,
   setBranchLinkInBody,
   skip,
   toVSCodeSettings,
+  unregisterAgent,
+  updateAgent,
   useCli,
   useCustom,
   useVSCode,