@link-assistant/hive-mind 1.60.0 → 1.62.0

package/src/qwen.prompts.lib.mjs

@@ -0,0 +1,253 @@
+/**
+ * Qwen prompts module
+ * Handles building prompts for Qwen Code commands
+ */
+
+import { getArchitectureCareSubPrompt } from './architecture-care.prompts.lib.mjs';
+import { getExperimentsExamplesSubPrompt } from './experiments-examples.prompts.lib.mjs';
+import { getThinkingPromptInstruction } from './thinking-prompt.lib.mjs';
+
+/**
+ * Build the user prompt for Qwen Code
+ * @param {Object} params - Parameters for building the user prompt
+ * @returns {string} The formatted user prompt
+ */
+export const buildUserPrompt = params => {
+  const { issueUrl, issueNumber, prNumber, prUrl, branchName, tempDir, workspaceTmpDir, isContinueMode, forkedRepo, feedbackLines, forkActionsUrl, owner, repo, argv } = params;
+
+  const promptLines = [];
+
+  if (isContinueMode) {
+    promptLines.push(`Issue to solve: ${issueNumber ? `https://github.com/${owner}/${repo}/issues/${issueNumber}` : `Issue linked to PR #${prNumber}`}`);
+  } else {
+    promptLines.push(`Issue to solve: ${issueUrl}`);
+  }
+
+  promptLines.push(`Your prepared branch: ${branchName}`);
+  promptLines.push(`Your prepared working directory: ${tempDir}`);
+
+  if (workspaceTmpDir) {
+    promptLines.push(`Your prepared tmp directory for logs and downloads: ${workspaceTmpDir}`);
+  }
+
+  if (prUrl) {
+    promptLines.push(`Your prepared Pull Request: ${prUrl}`);
+  }
+
+  if (argv && argv.fork && forkedRepo) {
+    promptLines.push(`Your forked repository: ${forkedRepo}`);
+    promptLines.push(`Original repository (upstream): ${owner}/${repo}`);
+
+    if (branchName && forkActionsUrl) {
+      promptLines.push(`GitHub Actions on your fork: ${forkActionsUrl}`);
+    }
+  }
+
+  promptLines.push('');
+
+  if (isContinueMode && feedbackLines && feedbackLines.length > 0) {
+    feedbackLines.forEach(line => promptLines.push(line));
+    promptLines.push('');
+  }
+
+  const thinkingPromptInstruction = getThinkingPromptInstruction({ tool: 'qwen', argv });
+  if (thinkingPromptInstruction) {
+    promptLines.push(thinkingPromptInstruction);
+  }
+
+  promptLines.push(isContinueMode ? 'Continue.' : 'Proceed.');
+
+  return promptLines.join('\n') + '\n';
+};
+
+/**
+ * Build the system prompt for Qwen Code
+ * @param {Object} params - Parameters for building the prompt
+ * @returns {string} The formatted system prompt
+ */
+export const buildSystemPrompt = params => {
+  const { owner, repo, issueNumber, prNumber, branchName, workspaceTmpDir, argv, modelSupportsVision, forkedRepo } = params;
+
+  const screenshotRepoPath = argv?.fork && forkedRepo ? forkedRepo : `${owner}/${repo}`;
+
+  let workspaceInstructions = '';
+  if (workspaceTmpDir) {
+    workspaceInstructions = `
+Workspace tmp directory.
+   - Use ${workspaceTmpDir} for all temporary files, logs, and downloads.
+   - When saving command output to files, save to ${workspaceTmpDir}/command-output.log.
+   - When downloading CI logs, save to ${workspaceTmpDir}/ci-logs/.
+   - When saving diffs for review, save to ${workspaceTmpDir}/diffs/.
+   - When creating debug files, save to ${workspaceTmpDir}/debug/.
+
+`;
+  }
+
+  let ciExamples = '';
+  if (workspaceTmpDir) {
+    ciExamples = `
+CI investigation with workspace tmp directory.
+   - When downloading CI run logs:
+      gh run view RUN_ID --repo ${owner}/${repo} --log > ${workspaceTmpDir}/ci-logs/run-RUN_ID.log
+   - When downloading failed job logs:
+      gh run view RUN_ID --repo ${owner}/${repo} --log-failed > ${workspaceTmpDir}/ci-logs/run-RUN_ID-failed.log
+   - When listing CI runs with details:
+      gh run list --repo ${owner}/${repo} --branch ${branchName} --limit 5 --json databaseId,conclusion,createdAt,headSha > ${workspaceTmpDir}/ci-logs/recent-runs.json
+   - When saving PR diff for review:
+      gh pr diff ${prNumber} --repo ${owner}/${repo} > ${workspaceTmpDir}/diffs/pr-${prNumber}.diff
+   - When saving command output with stderr:
+      npm test 2>&1 | tee ${workspaceTmpDir}/test-output.log
+   - When investigating issue details:
+      gh issue view ${issueNumber} --repo ${owner}/${repo} --json body,comments > ${workspaceTmpDir}/issue-${issueNumber}.json
+
+`;
+  }
+
+  return `You are an AI issue solver using Qwen Code.
+
+General guidelines.
+   - When you execute commands and the output becomes large, save the logs to files for easier review.
+   - When running commands, avoid setting a timeout yourself. Let them run as long as needed.
+   - When running sudo commands, especially package installations, run them in the background to avoid timeout issues.
+   - When CI is failing, download the logs locally and investigate them carefully.
+   - When a code or log file has more than 1500 lines, read it in chunks of 1500 lines.
+   - When facing a complex problem, do as much tracing as possible and turn on all verbose modes.
+${getExperimentsExamplesSubPrompt(argv)}
+   - When you face something extremely hard, use divide and conquer.
+${workspaceInstructions}
+Initial research.
+   - When you start, create a detailed plan for yourself and follow your todo list step by step. Add as many relevant points from these guidelines to the todo list as practical so you can track the work clearly.
+   - When you read the issue, read all details and comments thoroughly.
+   - When you see screenshots or images in issue descriptions, pull request descriptions, comments, or discussions, download the image to a local file first, then use the Read tool to view and analyze it. Before reading downloaded images with the Read tool, verify that the file is a valid image rather than HTML by using a CLI tool such as the 'file' command. When the file command shows "HTML", "text", or "ASCII text", the download failed, so do not call Read on that file. When images are from GitHub issues or PRs, such as URLs containing "github.com/user-attachments", use: curl -L -H "Authorization: token $(gh auth token)" -o <filename> "<url>"
+   - When you need issue details, use gh issue view https://github.com/${owner}/${repo}/issues/${issueNumber}.
+   - When you need related code, use gh search code --owner ${owner} [keywords].
+   - When you need repo context, read files in your working directory.${
+     argv?.promptCheckSiblingPullRequests !== false
+       ? `
+   - When you study related work, study the most recent related pull requests.`
+       : ''
+   }
+   - When the issue is not defined clearly enough, write a comment with clarifying questions.
+   - When accessing GitHub Gists, use gh gist view command instead of direct URL fetching.
+   - When you are fixing a bug, find the actual root cause first and run as many experiments as needed.
+   - When you are fixing a bug and the code does not have enough tracing or logs, add them and keep them in the code with the default state switched off.
+   - When you need comments on a pull request, note that GitHub has three different comment types with different API endpoints:
+      1. PR review comments (inline code comments): gh api repos/${owner}/${repo}/pulls/${prNumber}/comments --paginate
+      2. PR conversation comments (general discussion): gh api repos/${owner}/${repo}/issues/${prNumber}/comments --paginate
+      3. PR reviews (approve/request changes): gh api repos/${owner}/${repo}/pulls/${prNumber}/reviews --paginate
+      Note: The command "gh pr view --json comments" only returns conversation comments and misses review comments.
+   - When you need the latest comments on the issue, use gh api repos/${owner}/${repo}/issues/${issueNumber}/comments --paginate.
+
+Solution development and testing.
+   - When issue is solvable, first create a test that reproduces the problem, then implement the fix.
+   - When implementing features, search for similar existing implementations in the codebase and use them as examples instead of implementing everything from scratch.
+   - When coding, commit each atomic step that is useful on its own to the pull request branch so interrupted work remains preserved in the pull request.
+   - When you test:
+      start from testing of small functions using separate scripts;
+      write unit tests with mocks for easy and quick start.
+   - When you test integrations, use existing framework.
+   - When you test solution draft, include automated checks in pr.
+   - When you write or modify tests, consider setting reasonable timeouts at test, suite, and CI job levels so failures surface quickly instead of hanging.
+   - When you see repeated test timeout patterns in CI, investigate the root cause rather than increasing timeouts.
+   - When the issue is unclear, write a comment on the issue with questions.
+   - When you encounter any problems that you are unable to solve yourself, write a comment to the pull request asking for help.
+   - When you need human help, use gh pr comment ${prNumber} --body "your message" to comment on existing PR.
+
+Reproducible testing.
+   - When fixing a bug, create a test that reproduces the problem before implementing the fix. When you cannot reproduce the problem, you cannot verify the fix.
+   - When encountering logic bugs, write an automated test that fails due to the bug, then implement the fix to make it pass.
+   - When encountering UI bugs, capture a screenshot showing the problem state, then create a visual regression test or manual verification screenshot after the fix.
+   - When creating tests, prefer minimum reproducible examples, meaning the simplest test case that demonstrates the issue.
+   - When submitting a fix, include in the PR description: (1) how to reproduce the issue, (2) the automated test that verifies the fix, (3) before/after screenshots for UI issues.
+   - When a bug fix does not have a reproducing test, treat the fix as incomplete because regressions can occur later without notice.
+
+Preparing pull request.
+   - When you code, follow contributing guidelines.
+   - When you commit, write clear message.
+   - When you need examples of style, use gh pr list --repo ${owner}/${repo} --state merged --search [keywords].
+   - When you open pr, describe solution draft and include tests.
+   - When there is a package with version and GitHub Actions workflows for automatic release, update the version in your pull request to prepare for next release.
+   - When you update existing pr ${prNumber}, use gh pr edit to modify title and description.
+   - When you finalize the pull request:
+      check that the pull request title and description are updated (the PR may start with a [WIP] prefix and a placeholder description that should be replaced with the actual title and description of the changes),
+      follow style from merged prs for code, title, and description,
+      check that no uncommitted changes corresponding to the original requirements are left behind,
+      check that the default branch is merged into the pull request branch,
+      check that all CI checks are passing if they exist before you finish,
+      double-check that all changes in the pull request address the original requirements of the issue,
+      check for newly introduced bugs in the pull request by carefully reading gh pr diff,
+      check that no previously existing features were removed without an explicit request in the issue description, issue comments, or pull request comments.
+   - When you finish implementation, use gh pr ready ${prNumber}.
+
+Workflow and collaboration.
+   - When you check branch, verify with git branch --show-current.
+   - When you push, push only to branch ${branchName}.
+   - When you finish, create a pull request from branch ${branchName}.
+   - When pr ${prNumber} already exists for this branch, update it instead of creating new one.
+   - When you organize workflow, use pull requests instead of direct merges to default branch (main or master).
+   - When you manage commits, preserve commit history for later analysis.
+   - When you contribute, keep repository history forward-moving with regular commits, pushes, and reverts if needed.
+   - When you face conflict that you cannot resolve yourself, ask for help.
+   - When you collaborate, respect branch protections by working only on ${branchName}.
+   - When you mention a result, include the pull request URL or comment URL.
+   - When you need to create pr, remember pr ${prNumber} already exists for this branch.
+
+Self review.
+   - When you check your solution draft, run all tests locally.
+   - When you compare with repo style, use gh pr diff [number].
+   - When you finalize, confirm code, tests, and description are consistent.${
+     argv && argv.promptEnsureAllRequirementsAreMet
+       ? `
+   - When no explicit feedback or requirements are provided, ensure all changes are correct, consistent, validated, tested, logged, and aligned with all discussed requirements by checking the issue description and all comments on the issue and pull request. Check that all CI or CD checks are passing.`
+       : ''
+   }
+
+GitHub CLI command patterns.
+   - When fetching lists from GitHub API, use the --paginate flag to ensure all results are returned (GitHub returns max 30 per page by default).
+   - When listing PR review comments (inline code comments), use gh api repos/OWNER/REPO/pulls/NUMBER/comments --paginate.
+   - When listing PR conversation comments, use gh api repos/OWNER/REPO/issues/NUMBER/comments --paginate.
+   - When listing PR reviews, use gh api repos/OWNER/REPO/pulls/NUMBER/reviews --paginate.
+   - When listing issue comments, use gh api repos/OWNER/REPO/issues/NUMBER/comments --paginate.
+   - When adding PR comment, use gh pr comment NUMBER --body "text" --repo OWNER/REPO.
+   - When adding issue comment, use gh issue comment NUMBER --body "text" --repo OWNER/REPO.
+   - When viewing PR details, use gh pr view NUMBER --repo OWNER/REPO.
+   - When filtering with jq, use gh api repos/${owner}/${repo}/pulls/${prNumber}/comments --paginate --jq 'reverse | .[0:5]'.${
+     argv && argv.promptPlaywrightMcp
+       ? `
+
+Playwright MCP usage (browser automation via MCP tools).
+   - When you develop frontend web applications (HTML, CSS, JavaScript, React, Vue, Angular, etc.), use Playwright MCP tools to test the UI in a real browser.
+   - When WebFetch tool fails to retrieve expected content (e.g., returns empty content, JavaScript-rendered pages, or login-protected pages), use Playwright MCP tools (browser_navigate, browser_snapshot) as a fallback for web browsing.
+   - When WebSearch tool fails or returns insufficient results, use Playwright MCP tools (browser_navigate, browser_snapshot) as a fallback for internet search.
+   - When you need to interact with dynamic web pages that require JavaScript execution, use Playwright MCP tools.
+   - When you need to visually verify how a web page looks or take screenshots, use browser_take_screenshot from Playwright MCP.
+   - When you need to fill forms, click buttons, or perform user interactions on web pages, use Playwright MCP tools (browser_click, browser_type, browser_fill_form).
+   - When you need to test responsive design or different viewport sizes, use browser_resize from Playwright MCP.
+   - When you finish using the browser, close it with browser_close to free resources.
+   - When reproducing UI bugs, use browser_take_screenshot to capture the problem state before implementing any fix.
+   - When fixing UI bugs, take before/after screenshots to provide visual evidence of the fix for human verification.
+   - When creating UI tests, save baseline screenshots to the repository for visual regression testing.
+   - When verifying UI fixes, compare screenshots to ensure the fix does not introduce unintended visual changes.`
+       : ''
+   }${
+     modelSupportsVision
+       ? `
+
+Visual UI work and screenshots.
+   - When you work on visual UI changes (frontend, CSS, HTML, design), include a render or screenshot of the final result in the pull request description.
+   - When you need to show visual results, take a screenshot and save it to the repository (e.g., in a docs/screenshots/ or assets/ folder).
+   - When you save screenshots to the repository, use permanent links in the pull request description markdown (e.g., https://github.com/${screenshotRepoPath}/blob/${branchName}/docs/screenshots/result.png?raw=true).
+   - When uploading images, commit them to the branch first, then reference them using the GitHub blob URL format with ?raw=true suffix (works for both public and private repositories).
+   - When the visual result is important for review, mention it explicitly in the pull request description with the embedded image.
+   - When fixing UI bugs, capture both the "before" (problem) and "after" (fixed) screenshots as evidence for human verification of the fix.
+   - When reporting UI bugs, include a screenshot of the problem state to enable visual verification of the fix.
+   - When the fix is visual, include side-by-side or sequential comparison of before/after states in the PR description.
+   - When possible, create automated visual regression tests to prevent the UI bug from recurring.`
+       : ''
+   }${ciExamples}${getArchitectureCareSubPrompt(argv)}`;
+};
+
+export default {
+  buildUserPrompt,
+  buildSystemPrompt,
+};

package/src/solve.config.lib.mjs

@@ -327,7 +327,7 @@ export const SOLVE_OPTION_DEFINITIONS = {
   tool: {
     type: 'string',
     description: 'AI tool to use for solving issues',
-    choices: ['claude', 'opencode', 'codex', 'agent'],
+    choices: ['claude', 'opencode', 'codex', 'agent', 'qwen'],
     default: 'claude',
   },
   plan: {
@@ -352,7 +352,7 @@ export const SOLVE_OPTION_DEFINITIONS = {
   },
   'enable-workspaces': {
     type: 'boolean',
-    description: 'Use separate workspace directory structure with repository/ and tmp/ folders. Works with all tools (claude, opencode, codex, agent). Experimental feature.',
+    description: 'Use separate workspace directory structure with repository/ and tmp/ folders. Works with all tools (claude, opencode, codex, agent, qwen). Experimental feature.',
     default: false,
   },
   'interactive-mode': {
@@ -428,7 +428,7 @@ export const SOLVE_OPTION_DEFINITIONS = {
   },
   'prompt-playwright-mcp': {
     type: 'boolean',
-    description: 'Enable Playwright MCP browser automation hints in system prompt (enabled by default, only takes effect if Playwright MCP is installed). Use --no-prompt-playwright-mcp to disable. Supported for --tool claude, --tool codex, --tool opencode, and --tool agent.',
+    description: 'Enable Playwright MCP browser automation hints in system prompt (enabled by default, only takes effect if Playwright MCP is installed). Use --no-prompt-playwright-mcp to disable. Supported for --tool claude, --tool codex, --tool opencode, --tool agent, and --tool qwen.',
     default: true,
   },
   'prompt-check-sibling-pull-requests': {
@@ -448,7 +448,7 @@ export const SOLVE_OPTION_DEFINITIONS = {
   },
   'playwright-mcp': {
     type: 'boolean',
-    description: 'Enable Playwright MCP server connection for this session (enabled by default). Use --no-playwright-mcp to physically disable the Playwright MCP server without affecting the global MCP registration. When disabled, also disables --prompt-playwright-mcp and --playwright-mcp-auto-cleanup. Supported for --tool claude, --tool codex, --tool opencode, and --tool agent.',
+    description: 'Enable Playwright MCP server connection for this session (enabled by default). Use --no-playwright-mcp to physically disable the Playwright MCP server without affecting the global MCP registration. When disabled, also disables --prompt-playwright-mcp and --playwright-mcp-auto-cleanup. Supported for --tool claude, --tool codex, --tool opencode, --tool agent, and --tool qwen.',
     default: true,
   },
   'playwright-mcp-auto-cleanup': {
@@ -468,7 +468,7 @@ export const SOLVE_OPTION_DEFINITIONS = {
   },
   'prompt-subagents-via-agent-commander': {
     type: 'boolean',
-    description: 'Guide AI to use agent-commander CLI (start-agent) instead of native tool-specific delegation for subagent work. Allows using any supported agent type (claude, opencode, codex, agent) with a unified API. Supported for --tool claude and --tool codex and requires agent-commander to be installed.',
+    description: 'Guide AI to use agent-commander CLI (start-agent) instead of native tool-specific delegation for subagent work. Allows using any supported agent type (claude, opencode, codex, agent, qwen) with a unified API. Supported for --tool claude and --tool codex and requires agent-commander to be installed.',
     default: false,
   },
   'auto-init-repository': {

package/src/solve.mjs

@@ -99,6 +99,9 @@ if (argv.tool === 'opencode') {
 } else if (argv.tool === 'agent') {
   const agentLib = await import('./agent.lib.mjs');
   checkForUncommittedChanges = agentLib.checkForUncommittedChanges;
+} else if (argv.tool === 'qwen') {
+  const qwenLib = await import('./qwen.lib.mjs');
+  checkForUncommittedChanges = qwenLib.checkForUncommittedChanges;
 } else {
   checkForUncommittedChanges = claudeLib.checkForUncommittedChanges;
 }
@@ -751,6 +754,36 @@ try {
       agentPath,
       $,
     });
+  } else if (argv.tool === 'qwen') {
+    const qwenLib = await import('./qwen.lib.mjs');
+    const { executeQwen, checkPlaywrightMcpAvailability: checkQwenPlaywrightMcp } = qwenLib;
+    const qwenPath = process.env.QWEN_PATH || 'qwen';
+    await resolvePlaywrightMcp(checkQwenPlaywrightMcp);
+
+    toolResult = await executeQwen({
+      issueUrl,
+      issueNumber,
+      prNumber,
+      prUrl,
+      branchName,
+      tempDir,
+      workspaceTmpDir,
+      isContinueMode,
+      mergeStateStatus,
+      forkedRepo,
+      feedbackLines,
+      forkActionsUrl,
+      owner,
+      repo,
+      argv,
+      log,
+      setLogFile,
+      getLogFile,
+      formatAligned,
+      getResourceSnapshot,
+      qwenPath,
+      $,
+    });
   } else {
     // Default to Claude
     if (argv.tool === 'claude' || !argv.tool) {
@@ -1150,6 +1183,7 @@ try {
       prNumber,
       branchName,
       tempDir,
+      workspaceTmpDir,
       mergeStateStatus,
       feedbackLines: hintLines,
       argv: {

package/src/solve.restart-shared.lib.mjs

@@ -167,13 +167,13 @@ export const getUncommittedChangesDetails = async tempDir => {
 };
 
 /**
- * Execute the AI tool (Claude, OpenCode, Codex, Agent) for a restart iteration
+ * Execute the AI tool (Claude, OpenCode, Codex, Agent, Qwen) for a restart iteration
  * This is the shared tool execution logic used by both watch mode and auto-restart-until-mergeable mode
  * @param {Object} params - Execution parameters
  * @returns {Promise<Object>} - Tool execution result
  */
 export const executeToolIteration = async params => {
-  const { issueUrl, owner, repo, issueNumber, prNumber, branchName, tempDir, mergeStateStatus, feedbackLines, argv } = params;
+  const { issueUrl, owner, repo, issueNumber, prNumber, branchName, tempDir, workspaceTmpDir, mergeStateStatus, feedbackLines, argv } = params;
 
   // Import necessary modules for tool execution
   const memoryCheck = await import('./memory-check.mjs');
@@ -301,6 +301,48 @@ export const executeToolIteration = async params => {
       agentPath,
       $,
     });
+  } else if (argv.tool === 'qwen') {
+    // Use Qwen Code
+    const qwenExecLib = await import('./qwen.lib.mjs');
+    const { executeQwen, checkPlaywrightMcpAvailability } = qwenExecLib;
+    const qwenPath = argv.qwenPath || 'qwen';
+
+    if (argv.promptPlaywrightMcp) {
+      const playwrightMcpAvailable = await checkPlaywrightMcpAvailability();
+      if (playwrightMcpAvailable) {
+        await log('🎭 Playwright MCP detected - enabling browser automation hints', { verbose: true });
+      } else {
+        await log('ℹ️  Playwright MCP not detected - browser automation hints will be disabled', { verbose: true });
+        argv.promptPlaywrightMcp = false;
+      }
+    } else {
+      await log('ℹ️  Playwright MCP explicitly disabled via --no-prompt-playwright-mcp', { verbose: true });
+    }
+
+    toolResult = await executeQwen({
+      issueUrl,
+      issueNumber,
+      prNumber,
+      prUrl: `https://github.com/${owner}/${repo}/pull/${prNumber}`,
+      branchName,
+      tempDir,
+      workspaceTmpDir,
+      isContinueMode: true,
+      mergeStateStatus,
+      forkedRepo: argv.fork,
+      feedbackLines,
+      forkActionsUrl: null,
+      owner,
+      repo,
+      argv,
+      log,
+      setLogFile: () => {},
+      getLogFile: () => '',
+      formatAligned,
+      getResourceSnapshot,
+      qwenPath,
+      $,
+    });
   } else {
     // Use Claude (default)
     const claudeExecLib = await import('./claude.lib.mjs');

package/src/solve.validation.lib.mjs

@@ -319,6 +319,14 @@ export const performSystemChecks = async (minDiskSpace = 2048, skipToolConnectio
         await log('❌ Cannot proceed without Agent connection', { level: 'error' });
         return false;
       }
+    } else if (argv.tool === 'qwen') {
+      // Validate Qwen Code connection
+      const qwenLib = await import('./qwen.lib.mjs');
+      isToolConnected = await qwenLib.validateQwenConnection(model);
+      if (!isToolConnected) {
+        await log('❌ Cannot proceed without Qwen Code connection', { level: 'error' });
+        return false;
+      }
     } else {
       // Validate Claude CLI connection (default)
       const isClaudeConnected = await validateClaudeConnection(model);

package/src/task.issue-creation.lib.mjs

@@ -0,0 +1,203 @@
+import os from 'os';
+import path from 'path';
+import { spawn } from 'child_process';
+import { promises as fs } from 'fs';
+import { parseGitHubUrl } from './github.lib.mjs';
+
+export const TASK_ISSUE_TITLE_MAX_LENGTH = 256;
+
+function normalizeNewlines(value) {
+  return String(value || '').replace(/\r\n?/g, '\n');
+}
+
+function cleanRepositoryCandidate(value) {
+  return String(value || '')
+    .trim()
+    .replace(/^[<([{]+/, '')
+    .replace(/[>\])}.,;:]+$/, '');
+}
+
+export function stripTaskCommandPrefix(text) {
+  const value = normalizeNewlines(text).trimStart();
+  return value.replace(/^\/(?:task|split)(?:@\S+)?(?:[ \t]+|\n|$)/i, '').trim();
+}
+
+export function resolveTaskIssueCreationInput({ commandText = '', replyText = '' } = {}) {
+  const inlineText = stripTaskCommandPrefix(commandText);
+  if (inlineText) return inlineText;
+  return normalizeNewlines(replyText).trim();
+}
+
+export function parseTaskRepository(value) {
+  const candidate = cleanRepositoryCandidate(value);
+  const parsed = parseGitHubUrl(candidate);
+  if (!parsed.valid || parsed.type !== 'repo') return null;
+  return {
+    owner: parsed.owner,
+    repo: parsed.repo,
+    fullName: `${parsed.owner}/${parsed.repo}`,
+    url: `https://github.com/${parsed.owner}/${parsed.repo}`,
+  };
+}
+
+function parseRepositoryDirective(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith('--repository')) return { matched: false };
+
+  const match = trimmed.match(/^--repository(?:=(\S+)|\s+(\S+))$/);
+  if (!match) {
+    return {
+      matched: true,
+      error: 'Invalid --repository syntax. Use --repository <github-repository-url>.',
+    };
+  }
+
+  const repository = parseTaskRepository(match[1] || match[2]);
+  if (!repository) {
+    return {
+      matched: true,
+      error: '--repository must point to a GitHub repository URL.',
+    };
+  }
+
+  return { matched: true, repository };
+}
+
+function parseRepositoryLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || /\s/.test(trimmed)) return null;
+  return parseTaskRepository(trimmed);
+}
+
+function setRepository(currentRepository, nextRepository) {
+  if (!nextRepository) return { repository: currentRepository };
+  if (currentRepository) {
+    return {
+      repository: currentRepository,
+      error: 'Only one GitHub repository may be provided.',
+    };
+  }
+  return { repository: nextRepository };
+}
+
+export function buildTaskIssueTitle(issueText, maxLength = TASK_ISSUE_TITLE_MAX_LENGTH) {
+  const firstLine = normalizeNewlines(issueText).trim().split('\n')[0]?.trim() || 'New task';
+  if (firstLine.length <= maxLength) return firstLine;
+  return `${firstLine.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
+}
+
+export function parseTaskIssueCreationInput(input) {
+  const normalized = normalizeNewlines(input).trim();
+  if (!normalized) {
+    return { valid: false, error: 'Missing repository and issue text.' };
+  }
+
+  const lines = normalized.split('\n');
+  let repository = null;
+  let bodyLines = [];
+
+  for (const line of lines) {
+    const directive = parseRepositoryDirective(line);
+    if (!directive.matched) {
+      bodyLines.push(line);
+      continue;
+    }
+    if (directive.error) return { valid: false, error: directive.error };
+    const next = setRepository(repository, directive.repository);
+    if (next.error) return { valid: false, error: next.error };
+    repository = next.repository;
+  }
+
+  if (!repository) {
+    bodyLines = [];
+    for (const line of lines) {
+      const lineRepository = parseRepositoryLine(line);
+      if (!lineRepository) {
+        bodyLines.push(line);
+        continue;
+      }
+      const next = setRepository(repository, lineRepository);
+      if (next.error) return { valid: false, error: next.error };
+      repository = next.repository;
+    }
+  }
+
+  if (!repository) {
+    return {
+      valid: false,
+      error: 'Missing GitHub repository URL. Provide it on its own line or with --repository <github-repository-url>.',
+    };
+  }
+
+  const issueText = bodyLines.join('\n').trim();
+  if (!issueText) {
+    return { valid: false, error: 'Missing issue text.' };
+  }
+
+  return {
+    valid: true,
+    repository,
+    issueText,
+    title: buildTaskIssueTitle(issueText),
+  };
+}
+
+function runCommand(command, args, options = {}) {
+  return new Promise(resolve => {
+    const child = spawn(command, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: process.env,
+      ...options,
+    });
+
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', data => {
+      stdout += data.toString();
+    });
+    child.stderr.on('data', data => {
+      stderr += data.toString();
+    });
+    child.on('error', error => {
+      resolve({ code: 1, stdout, stderr: stderr || error.message });
+    });
+    child.on('close', code => {
+      resolve({ code, stdout, stderr });
+    });
+  });
+}
+
+export function parseCreatedTaskIssueOutput(output) {
+  const tokens = String(output || '')
+    .split(/\s+/)
+    .filter(Boolean);
+  for (const token of tokens) {
+    const parsed = parseGitHubUrl(cleanRepositoryCandidate(token));
+    if (parsed.valid && parsed.type === 'issue') {
+      return {
+        owner: parsed.owner,
+        repo: parsed.repo,
+        number: parsed.number,
+        url: parsed.normalized,
+      };
+    }
+  }
+  throw new Error(`Could not parse created issue URL from gh output: ${String(output || '').trim()}`);
+}
+
+export async function createTaskIssue({ repository, title, body, run = runCommand }) {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'hive-mind-task-issue-'));
+  const bodyFile = path.join(tempDir, 'body.md');
+
+  try {
+    await fs.writeFile(bodyFile, body);
+    const result = await run('gh', ['issue', 'create', '--repo', repository.fullName, '--title', title, '--body-file', bodyFile]);
+    if (result.code !== 0) {
+      const output = `${result.stderr || ''}${result.stdout || ''}`.trim();
+      throw new Error(output || `gh issue create exited with code ${result.code}`);
+    }
+    return parseCreatedTaskIssueOutput(result.stdout);
+  } finally {
+    await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+  }
+}

package/src/task.mjs

@@ -33,7 +33,7 @@ if (earlyArgs.length === 0 || earlyArgs.includes('--help') || earlyArgs.includes
   console.log('  --only-decompose   Only run decomposition mode');
   console.log('  --split            Split a GitHub issue into smaller issues');
   console.log('  --split-count      Number of issues to split into [default: 2]');
-  console.log('  --tool             AI tool for agent-commander read-only mode (claude, codex, opencode, agent) [default: claude]');
+  console.log('  --tool             AI tool for agent-commander read-only mode (claude, codex, opencode, agent, qwen) [default: claude]');
   console.log('  --model, -m        Model to use');
   console.log('  --isolation        agent-commander isolation mode [default: screen]');
   console.log('  --dry-run          Print split output without creating GitHub issues');