@phren/cli 0.0.1

package/mcp/dist/task-hygiene.js

@@ -0,0 +1,251 @@
+import * as fs from "fs";
+import * as path from "path";
+import { isTaskFileName, readTasks } from "./data-tasks.js";
+import { STOP_WORDS, extractKeywords, errorMessage } from "./utils.js";
+const TEXT_EXTENSIONS = new Set([
+    ".cjs",
+    ".css",
+    ".go",
+    ".html",
+    ".java",
+    ".js",
+    ".json",
+    ".jsx",
+    ".kt",
+    ".md",
+    ".mjs",
+    ".py",
+    ".rb",
+    ".rs",
+    ".scss",
+    ".sh",
+    ".sql",
+    ".swift",
+    ".toml",
+    ".ts",
+    ".tsx",
+    ".txt",
+    ".yaml",
+    ".yml",
+]);
+const SKIP_DIRS = new Set([
+    ".git",
+    ".next",
+    ".turbo",
+    "build",
+    "coverage",
+    "dist",
+    "node_modules",
+    "target",
+]);
+const GENERIC_TASK_TERMS = new Set([
+    "add",
+    "audit",
+    "task",
+    "check",
+    "checks",
+    "coverage",
+    "doctor",
+    "docs",
+    "environment",
+    "environments",
+    "finish",
+    "fix",
+    "harness",
+    "improve",
+    "install",
+    "installs",
+    "integration",
+    "item",
+    "items",
+    "maintain",
+    "message",
+    "messages",
+    "next",
+    "pass",
+    "project",
+    "projects",
+    "queue",
+    "queued",
+    "refactor",
+    "repo",
+    "search",
+    "setup",
+    "stability",
+    "support",
+    "test",
+    "tests",
+    "workflow",
+]);
+const MAX_TEXT_BYTES = 16 * 1024;
+const MAX_FILES_PER_ROOT = 400;
+function uniqueValues(values) {
+    const seen = new Set();
+    const out = [];
+    for (const value of values) {
+        const trimmed = value.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        out.push(trimmed);
+    }
+    return out;
+}
+function uniqueTerms(values) {
+    const seen = new Set();
+    const out = [];
+    for (const value of values) {
+        const trimmed = value.trim().toLowerCase();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        out.push(trimmed);
+    }
+    return out;
+}
+function isLikelyTextFile(filePath) {
+    return TEXT_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+function collectCorpus(root) {
+    if (!root || !fs.existsSync(root))
+        return [];
+    const texts = [];
+    const stack = [root];
+    let filesSeen = 0;
+    while (stack.length > 0 && filesSeen < MAX_FILES_PER_ROOT) {
+        const current = stack.pop();
+        let entries;
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                if (!SKIP_DIRS.has(entry.name))
+                    stack.push(fullPath);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if (isTaskFileName(entry.name))
+                continue;
+            filesSeen += 1;
+            const rel = path.relative(root, fullPath).replace(/\\/g, "/").toLowerCase();
+            texts.push(rel);
+            if (!isLikelyTextFile(fullPath))
+                continue;
+            try {
+                texts.push(fs.readFileSync(fullPath, "utf8").slice(0, MAX_TEXT_BYTES).toLowerCase());
+            }
+            catch (err) {
+                if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+                    process.stderr.write(`[phren] task hygiene read ${fullPath}: ${errorMessage(err)}\n`);
+            }
+            if (filesSeen >= MAX_FILES_PER_ROOT)
+                break;
+        }
+    }
+    return texts;
+}
+function corpusHas(corpus, term) {
+    const needle = term.trim().toLowerCase();
+    if (!needle)
+        return false;
+    return corpus.some((entry) => entry.includes(needle));
+}
+function extractAnchors(line) {
+    const anchors = [];
+    const backticks = [...line.matchAll(/`([^`]+)`/g)].map((match) => match[1]);
+    for (const raw of backticks) {
+        anchors.push(raw);
+        const base = path.basename(raw);
+        if (base && base !== raw)
+            anchors.push(base);
+    }
+    for (const match of line.matchAll(/([A-Za-z0-9_.-]+\.(?:cjs|css|go|html|java|js|json|jsx|kt|md|mjs|py|rb|rs|scss|sh|sql|swift|toml|ts|tsx|txt|yaml|yml))/g)) {
+        anchors.push(match[1]);
+    }
+    for (const match of line.matchAll(/\b(?:[A-Za-z0-9_.-]+\/)+[A-Za-z0-9_.-]+\b/g)) {
+        anchors.push(match[0]);
+        anchors.push(path.basename(match[0]));
+    }
+    for (const match of line.matchAll(/\b[A-Z][A-Za-z0-9]+(?:[A-Z][A-Za-z0-9]+)+\b/g)) {
+        anchors.push(match[0]);
+    }
+    return uniqueTerms(anchors.filter((term) => term.length >= 3));
+}
+function extractDistinctiveKeywords(line) {
+    const clean = line
+        .replace(/<!--.*?-->/g, " ")
+        .replace(/`[^`]+`/g, " ")
+        .replace(/\[(?:high|medium|low|pinned)\]/gi, " ");
+    const rawTerms = extractKeywords(clean).split(/\s+/).filter(Boolean);
+    return uniqueTerms(rawTerms.filter((term) => {
+        if (term.length < 4)
+            return false;
+        if (STOP_WORDS.has(term))
+            return false;
+        if (GENERIC_TASK_TERMS.has(term))
+            return false;
+        return true;
+    })).slice(0, 6);
+}
+function formatDetail(issues, roots) {
+    if (roots.length === 0)
+        return "skipped: no project repo/docs roots available for task hygiene scan";
+    if (issues.length === 0)
+        return `ok across ${roots.length} root${roots.length === 1 ? "" : "s"}`;
+    const preview = issues
+        .slice(0, 3)
+        .map((issue) => `${issue.id} ${issue.reason === "anchors-missing" ? "missing anchors" : "missing keywords"} (${issue.evidence.join(", ")})`)
+        .join("; ");
+    return `${issues.length} suspect task(s): ${preview}`;
+}
+export function inspectTaskHygiene(phrenPath, project, repoPath) {
+    const parsed = readTasks(phrenPath, project);
+    if (!parsed.ok) {
+        return { ok: true, detail: "skipped: tasks unavailable", issues: [] };
+    }
+    const roots = uniqueValues([
+        path.join(phrenPath, project),
+        repoPath || "",
+    ].filter((candidate) => candidate && fs.existsSync(candidate)));
+    const corpus = roots.flatMap((root) => collectCorpus(root));
+    const issues = [];
+    const items = [...parsed.data.items.Active, ...parsed.data.items.Queue];
+    for (const item of items) {
+        const anchors = extractAnchors(item.line);
+        if (anchors.length > 0) {
+            const matched = anchors.filter((term) => corpusHas(corpus, term));
+            if (matched.length === 0) {
+                issues.push({
+                    id: item.id,
+                    line: item.line,
+                    reason: "anchors-missing",
+                    evidence: anchors.slice(0, 3),
+                });
+            }
+            continue;
+        }
+        const keywords = extractDistinctiveKeywords(item.line);
+        if (keywords.length < 2)
+            continue;
+        const matched = keywords.filter((term) => corpusHas(corpus, term));
+        if (matched.length === 0) {
+            issues.push({
+                id: item.id,
+                line: item.line,
+                reason: "keywords-missing",
+                evidence: keywords.slice(0, 3),
+            });
+        }
+    }
+    return {
+        ok: issues.length === 0,
+        detail: formatDetail(issues, roots),
+        issues,
+    };
+}

package/mcp/dist/task-lifecycle.js

@@ -0,0 +1,347 @@
+import * as fs from "fs";
+import { addTask, completeTask, readTasks, resolveTaskItem, updateTask, } from "./data-access.js";
+import { parseGithubIssueUrl, resolveProjectGithubRepo } from "./tasks-github.js";
+import { getProactivityLevelForTask, shouldAutoCaptureTaskForLevel, hasExecutionIntent, hasDiscoveryIntent, hasSuppressTaskIntent, hasCodeChangeContext } from "./proactivity.js";
+import { getWorkflowPolicy } from "./shared-governance.js";
+import { debugLog, sessionMarker } from "./shared.js";
+import { errorMessage } from "./utils.js";
+import { incrementSessionTasksCompleted } from "./mcp-session.js";
+const ACTION_PREFIX_RE = /^(?:please\s+|can you\s+|could you\s+|would you\s+|i want you to\s+|i want to\s+|let(?:'|’)s\s+|lets\s+|help me\s+)/i;
+const EXPLICIT_TASK_PREFIX_RE = /^(?:add(?:\s+(?:this|that|it))?\s+(?:to\s+(?:the\s+)?)?(?:task|todo(?:\s+list)?|task(?:\s+list)?)|add\s+(?:a\s+)?task|put(?:\s+(?:this|that|it))?\s+(?:in|on)\s+(?:the\s+)?(?:task|todo(?:\s+list)?|task(?:\s+list)?))\s*(?::|-|,)?\s*/i;
+const NON_ACTIONABLE_RE = /\b(brainstorm|idea|ideas|maybe|what if|should we|could we|would it make sense|question|explain|why is|how does)\b/i;
+const ACTIONABLE_RE = /\b(add|build|change|complete|continue|create|delete|fix|implement|improve|investigate|make|move|refactor|remove|rename|repair|ship|start|update|wire)\b/i;
+const CONTINUE_RE = /\b(continue|keep going|finish|resume|pick up|work on that|that task)\b/i;
+const GITHUB_URL_RE = /https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/issues\/\d+(?:[?#][^\s]*)?/g;
+const GITHUB_ISSUE_RE = /(^|[^\w/])#(\d+)\b/g;
+const TASK_STOP_WORDS = new Set([
+    "about",
+    "after",
+    "again",
+    "also",
+    "auto",
+    "automatic",
+    "because",
+    "before",
+    "code",
+    "phren",
+    "current",
+    "during",
+    "feature",
+    "from",
+    "have",
+    "into",
+    "just",
+    "like",
+    "make",
+    "more",
+    "need",
+    "really",
+    "should",
+    "some",
+    "something",
+    "stuff",
+    "task",
+    "tasks",
+    "that",
+    "them",
+    "then",
+    "this",
+    "thing",
+    "want",
+    "with",
+    "work",
+]);
+function taskSessionPath(phrenPath, sessionId) {
+    return sessionMarker(phrenPath, `task-${sessionId}.json`);
+}
+function readTaskSessionState(phrenPath, sessionId) {
+    const file = taskSessionPath(phrenPath, sessionId);
+    if (!fs.existsSync(file))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch (err) {
+        debugLog(`task lifecycle read session ${sessionId}: ${errorMessage(err)}`);
+        return null;
+    }
+}
+function writeTaskSessionState(phrenPath, state) {
+    const file = taskSessionPath(phrenPath, state.sessionId);
+    fs.writeFileSync(file, JSON.stringify(state, null, 2) + "\n");
+}
+function clearTaskSessionState(phrenPath, sessionId) {
+    const file = taskSessionPath(phrenPath, sessionId);
+    try {
+        if (fs.existsSync(file))
+            fs.unlinkSync(file);
+    }
+    catch (err) {
+        debugLog(`task lifecycle clear session ${sessionId}: ${errorMessage(err)}`);
+    }
+}
+export function getTaskMode(phrenPath) {
+    return getWorkflowPolicy(phrenPath).taskMode;
+}
+function isActionablePrompt(prompt, intent) {
+    const normalized = prompt.trim();
+    if (!normalized)
+        return false;
+    if (NON_ACTIONABLE_RE.test(normalized))
+        return false;
+    if (intent === "general")
+        return ACTIONABLE_RE.test(normalized);
+    return true;
+}
+function normalizeTaskSummary(prompt) {
+    const withoutGithub = prompt
+        .replace(GITHUB_URL_RE, " ")
+        .replace(GITHUB_ISSUE_RE, "$1 ")
+        .replace(/\s+/g, " ")
+        .trim();
+    const stripped = withoutGithub.replace(ACTION_PREFIX_RE, "").trim();
+    const withoutTaskPrefix = stripped.replace(EXPLICIT_TASK_PREFIX_RE, "").trim();
+    const taskSource = withoutTaskPrefix || stripped;
+    const firstClause = taskSource.split(/[\n.!?]/)[0]?.trim() || taskSource;
+    const cleaned = firstClause
+        .replace(/^to\s+/i, "")
+        .replace(/\s+/g, " ")
+        .replace(/^["'`]+|["'`]+$/g, "")
+        .trim();
+    const capped = cleaned.length > 110 ? `${cleaned.slice(0, 109).trimEnd()}…` : cleaned;
+    if (!capped)
+        return "Follow up on current work";
+    return capped.charAt(0).toUpperCase() + capped.slice(1);
+}
+function tokenizeTaskText(value) {
+    return value
+        .toLowerCase()
+        .replace(/<!--.*?-->/g, " ")
+        .replace(/[`"'.,!?()[\]{}:/\\]/g, " ")
+        .split(/\s+/)
+        .filter((token) => token.length >= 4 && !TASK_STOP_WORDS.has(token));
+}
+function overlapScore(prompt, item) {
+    const promptTokens = new Set(tokenizeTaskText(prompt));
+    if (promptTokens.size === 0)
+        return 0;
+    const itemTokens = tokenizeTaskText(item.line);
+    let score = 0;
+    for (const token of itemTokens) {
+        if (promptTokens.has(token))
+            score += 1;
+    }
+    if (prompt.toLowerCase().includes(item.line.toLowerCase()))
+        score += 3;
+    return score;
+}
+function matchExistingActiveTask(prompt, activeItems) {
+    if (activeItems.length === 0)
+        return null;
+    if (activeItems.length === 1 && CONTINUE_RE.test(prompt))
+        return activeItems[0];
+    const ranked = activeItems
+        .map((item) => ({ item, score: overlapScore(prompt, item) }))
+        .filter((entry) => entry.score > 0)
+        .sort((a, b) => b.score - a.score);
+    if (ranked.length === 0)
+        return null;
+    if (ranked[0].score >= 2 && (ranked.length === 1 || ranked[0].score > ranked[1].score)) {
+        return ranked[0].item;
+    }
+    return null;
+}
+function resolveTrackedSessionTask(phrenPath, state) {
+    const match = state.stableId ? `bid:${state.stableId}` : state.item;
+    const resolved = resolveTaskItem(phrenPath, state.project, match);
+    return resolved.ok ? resolved.data : null;
+}
+function extractGithubMetadata(phrenPath, project, prompt) {
+    const repo = resolveProjectGithubRepo(phrenPath, project);
+    for (const match of prompt.matchAll(GITHUB_URL_RE)) {
+        const parsed = parseGithubIssueUrl(match[0]);
+        if (!parsed)
+            continue;
+        if (repo && parsed.repo && parsed.repo !== repo)
+            continue;
+        return {
+            github_issue: parsed.issueNumber,
+            github_url: parsed.url,
+        };
+    }
+    if (!repo)
+        return {};
+    const issueMatch = GITHUB_ISSUE_RE.exec(prompt);
+    GITHUB_ISSUE_RE.lastIndex = 0;
+    if (!issueMatch)
+        return {};
+    return { github_issue: Number.parseInt(issueMatch[2], 10) };
+}
+function buildSuggestionNotice(project, line, issueMeta) {
+    const githubLine = issueMeta.github_url
+        ? `Suggested link: ${issueMeta.github_url}`
+        : issueMeta.github_issue
+            ? `Suggested GitHub link: #${issueMeta.github_issue}`
+            : "";
+    return [
+        "<phren-notice>",
+        `Task suggestion for ${project}:`,
+        `- ${line}`,
+        ...(githubLine ? [githubLine] : []),
+        "<phren-notice>",
+    ];
+}
+function persistTaskAttachment(phrenPath, sessionId, project, item, summary, mode) {
+    writeTaskSessionState(phrenPath, {
+        sessionId,
+        project,
+        stableId: item.stableId,
+        item: item.line,
+        summary,
+        mode,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+    });
+}
+export function handleTaskPromptLifecycle(args) {
+    const mode = getTaskMode(args.phrenPath);
+    if (mode === "off" || mode === "manual" || !args.project || !args.sessionId) {
+        return { mode, noticeLines: [] };
+    }
+    // Suppression takes absolute priority — user explicitly said not to create a task.
+    if (hasSuppressTaskIntent(args.prompt)) {
+        debugLog(`task lifecycle suppressed ${args.project}: suppress-task intent detected`);
+        return { mode, noticeLines: [] };
+    }
+    if (!isActionablePrompt(args.prompt, args.intent)) {
+        return { mode, noticeLines: [] };
+    }
+    const taskLevel = args.taskLevel ?? getProactivityLevelForTask(args.phrenPath);
+    if (mode === "auto" && !shouldAutoCaptureTaskForLevel(taskLevel, args.prompt)) {
+        debugLog(`task lifecycle skipped ${args.project}: task proactivity=${taskLevel}`);
+        return { mode, noticeLines: [] };
+    }
+    const parsed = readTasks(args.phrenPath, args.project);
+    if (!parsed.ok)
+        return { mode, noticeLines: [] };
+    const summary = normalizeTaskSummary(args.prompt);
+    const issueMeta = extractGithubMetadata(args.phrenPath, args.project, args.prompt);
+    const trackedState = readTaskSessionState(args.phrenPath, args.sessionId);
+    const trackedItem = trackedState && trackedState.project === args.project
+        ? resolveTrackedSessionTask(args.phrenPath, trackedState)
+        : null;
+    const activeItems = parsed.data.items.Active;
+    const reusable = trackedItem && trackedItem.section === "Active"
+        ? trackedItem
+        : matchExistingActiveTask(args.prompt, activeItems);
+    if (mode === "suggest") {
+        const line = reusable?.line || summary;
+        return {
+            mode,
+            noticeLines: buildSuggestionNotice(args.project, line, issueMeta),
+        };
+    }
+    // Intent-aware auto mode: if the user is in discovery mode (brainstorming,
+    // exploring ideas) and NOT in execution mode (approving, committing to work,
+    // or performing code changes), create a speculative task and surface a suggestion.
+    if (mode === "auto" && !hasExecutionIntent(args.prompt) && !hasCodeChangeContext(args.prompt) && hasDiscoveryIntent(args.prompt)) {
+        const line = reusable?.line || summary;
+        debugLog(`task lifecycle auto→speculative ${args.project}: discovery intent detected`);
+        if (!reusable) {
+            addTask(args.phrenPath, args.project, summary, {
+                createdAt: new Date().toISOString(),
+                sessionId: args.sessionId,
+                speculative: true,
+            });
+        }
+        return {
+            mode: "auto",
+            noticeLines: buildSuggestionNotice(args.project, line, issueMeta),
+        };
+    }
+    const targetMatch = reusable?.stableId ? `bid:${reusable.stableId}` : reusable?.id;
+    if (!reusable) {
+        const add = addTask(args.phrenPath, args.project, summary, {
+            createdAt: new Date().toISOString(),
+            sessionId: args.sessionId,
+        });
+        if (!add.ok) {
+            debugLog(`task lifecycle add ${args.project}: ${add.error}`);
+            return { mode, noticeLines: [] };
+        }
+    }
+    const update = updateTask(args.phrenPath, args.project, targetMatch || summary, {
+        section: "active",
+        context: summary,
+        replace_context: true,
+        ...issueMeta,
+    });
+    if (!update.ok) {
+        debugLog(`task lifecycle update ${args.project}: ${update.error}`);
+        return { mode, noticeLines: [] };
+    }
+    const resolved = resolveTaskItem(args.phrenPath, args.project, targetMatch || summary);
+    if (!resolved.ok) {
+        debugLog(`task lifecycle resolve ${args.project}: ${resolved.error}`);
+        return { mode, noticeLines: [] };
+    }
+    persistTaskAttachment(args.phrenPath, args.sessionId, args.project, resolved.data, summary, "auto");
+    return {
+        mode,
+        noticeLines: [
+            "<phren-notice>",
+            `Active task (${args.project}): ${resolved.data.line}`,
+            "<phren-notice>",
+        ],
+    };
+}
+export function finalizeTaskSession(args) {
+    if (!args.sessionId || getTaskMode(args.phrenPath) !== "auto")
+        return;
+    const state = readTaskSessionState(args.phrenPath, args.sessionId);
+    if (!state || state.mode !== "auto")
+        return;
+    const match = state.stableId ? `bid:${state.stableId}` : state.item;
+    if (args.status === "saved-local" || args.status === "saved-pushed") {
+        const completed = completeTask(args.phrenPath, state.project, match);
+        if (!completed.ok) {
+            debugLog(`task lifecycle complete ${state.project}: ${completed.error}`);
+            return;
+        }
+        incrementSessionTasksCompleted(args.phrenPath, 1, state.sessionId, state.project);
+        clearTaskSessionState(args.phrenPath, args.sessionId);
+        return;
+    }
+    if (args.status === "error") {
+        const blocked = updateTask(args.phrenPath, state.project, match, {
+            section: "active",
+            context: `Blocked: ${args.detail}`,
+            replace_context: true,
+        });
+        if (!blocked.ok) {
+            debugLog(`task lifecycle block ${state.project}: ${blocked.error}`);
+            return;
+        }
+        writeTaskSessionState(args.phrenPath, {
+            ...state,
+            summary: `Blocked: ${args.detail}`,
+            updatedAt: new Date().toISOString(),
+        });
+        return;
+    }
+}
+export function clearTaskSession(phrenPath, sessionId) {
+    if (!sessionId)
+        return;
+    clearTaskSessionState(phrenPath, sessionId);
+}
+/**
+ * Return the active TaskItem tracked for a session+project, if any.
+ * Used by mcp-finding.ts to link findings to active tasks.
+ */
+export function getActiveTaskForSession(phrenPath, sessionId, project) {
+    const state = readTaskSessionState(phrenPath, sessionId);
+    if (!state || state.project !== project)
+        return null;
+    return resolveTrackedSessionTask(phrenPath, state);
+}

package/mcp/dist/tasks-github.js

@@ -0,0 +1,76 @@
+import * as fs from "fs";
+import * as path from "path";
+import { execFileSync } from "child_process";
+import { EXEC_TIMEOUT_MS, phrenErr, phrenOk, PhrenError } from "./shared.js";
+import { errorMessage, resolveExecCommand } from "./utils.js";
+const GITHUB_REPO_URL = /https:\/\/github\.com\/([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+)(?:\/|\b|$)/;
+const GITHUB_ISSUE_URL = /https:\/\/github\.com\/([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+)\/issues\/(\d+)(?:[?#][^\s]*)?$/;
+export function parseGithubIssueUrl(url) {
+    const trimmed = url.trim();
+    const match = trimmed.match(GITHUB_ISSUE_URL);
+    if (!match)
+        return null;
+    return {
+        repo: match[1],
+        issueNumber: Number.parseInt(match[2], 10),
+        url: match[0],
+    };
+}
+export function extractGithubRepoFromText(content) {
+    const match = content.match(GITHUB_REPO_URL);
+    return match?.[1];
+}
+export function resolveProjectGithubRepo(phrenPath, project) {
+    for (const file of ["CLAUDE.md", "summary.md"]) {
+        const fullPath = path.join(phrenPath, project, file);
+        if (!fs.existsSync(fullPath))
+            continue;
+        const repo = extractGithubRepoFromText(fs.readFileSync(fullPath, "utf8"));
+        if (repo)
+            return repo;
+    }
+    return undefined;
+}
+export function buildTaskIssueBody(project, item) {
+    const lines = [
+        `Imported from phren task for project \`${project}\`.`,
+        "",
+        `Task item: ${item.line}`,
+    ];
+    if (item.context) {
+        lines.push("", `Context: ${item.context}`);
+    }
+    if (item.stableId) {
+        lines.push("", `Task ID: \`bid:${item.stableId}\``);
+    }
+    return lines.join("\n");
+}
+export function createGithubIssueForTask(args) {
+    try {
+        const ghExec = resolveExecCommand("gh");
+        const stdout = execFileSync(ghExec.command, [
+            "issue",
+            "create",
+            "--repo",
+            args.repo,
+            "--title",
+            args.title,
+            "--body",
+            args.body,
+        ], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+            shell: ghExec.shell,
+            timeout: EXEC_TIMEOUT_MS,
+        }).trim();
+        const parsed = parseGithubIssueUrl(stdout);
+        return phrenOk({
+            repo: args.repo,
+            issueNumber: parsed?.issueNumber,
+            url: parsed?.url || stdout,
+        });
+    }
+    catch (err) {
+        return phrenErr(`Could not create GitHub issue. Ensure GitHub CLI is installed and authenticated: ${errorMessage(err)}`, PhrenError.NETWORK_ERROR);
+    }
+}