@goodtek/vibeops 0.7.22 → 1.1.1

package/dist/lib/pr-create.js

@@ -0,0 +1,66 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mergeRequestLabel } from "./git-host.js";
+import { log } from "./logger.js";
+const execFileAsync = promisify(execFile);
+async function ghPrCreate(opts) {
+    const { stdout } = await execFileAsync("gh", [
+        "pr",
+        "create",
+        "--base",
+        opts.baseBranch,
+        "--head",
+        opts.headBranch,
+        "--title",
+        opts.title,
+        "--body",
+        opts.body,
+    ], { cwd: opts.cwd, maxBuffer: 4 * 1024 * 1024 });
+    const line = stdout.trim().split("\n").pop()?.trim();
+    if (line && line.startsWith("http"))
+        return line;
+    throw new Error("gh pr create did not return a URL.");
+}
+async function glabMrCreate(opts) {
+    const { stdout } = await execFileAsync("glab", [
+        "mr",
+        "create",
+        "--target-branch",
+        opts.baseBranch,
+        "--source-branch",
+        opts.headBranch,
+        "--title",
+        opts.title,
+        "--description",
+        opts.body,
+    ], { cwd: opts.cwd, maxBuffer: 4 * 1024 * 1024 });
+    const line = stdout.trim().split("\n").pop()?.trim();
+    if (line && (line.startsWith("http") || line.includes("merge_requests")))
+        return line;
+    const match = stdout.match(/https?:\/\/[^\s]+/);
+    if (match)
+        return match[0];
+    throw new Error("glab mr create did not return a URL.");
+}
+export async function createMergeRequest(opts) {
+    const label = mergeRequestLabel(opts.host);
+    if (opts.dryRun) {
+        log.info(`would create ${label}: ${opts.headBranch} → ${opts.baseBranch}`);
+        return { url: `(dry-run ${label})` };
+    }
+    const url = opts.host === "gitlab" ? await glabMrCreate(opts) : await ghPrCreate(opts);
+    return { url };
+}
+export async function probeMergeRequestCli(host) {
+    try {
+        if (host === "gitlab") {
+            await execFileAsync("glab", ["--version"], { maxBuffer: 1024 });
+            return true;
+        }
+        await execFileAsync("gh", ["--version"], { maxBuffer: 1024 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/resolve-task.js

@@ -0,0 +1,34 @@
+import { findTaskFile, loadActionableTasks, pickActiveTask, pickInProgressTask, } from "./task.js";
+export function normalizeTaskRef(ref) {
+    const t = ref.trim();
+    if (/^task-/i.test(t) && !/^TASK-/i.test(t)) {
+        return `TASK-${t.replace(/^task-/i, "")}`;
+    }
+    return t.toUpperCase().startsWith("TASK-") ? t.toUpperCase() : `TASK-${t}`;
+}
+export async function resolveTask(paths, cwd, taskRef) {
+    const trimmed = taskRef?.trim();
+    if (trimmed !== undefined && trimmed.length > 0) {
+        const taskId = normalizeTaskRef(trimmed);
+        const taskFile = await findTaskFile(paths.docsTasks, taskId);
+        if (taskFile === null)
+            return null;
+        return { taskId, taskFile };
+    }
+    const tasks = await loadActionableTasks(paths.docsTasks);
+    const inProgress = pickInProgressTask(tasks);
+    if (inProgress !== null) {
+        return { taskId: inProgress.id, taskFile: inProgress.filePath };
+    }
+    const onBranch = await pickActiveTask(paths.docsTasks, cwd);
+    if (onBranch !== null && onBranch.status !== "done") {
+        return { taskId: onBranch.id, taskFile: onBranch.filePath };
+    }
+    return null;
+}
+export function taskNotFoundMessage(taskRef) {
+    if (taskRef?.trim()) {
+        return `TASK not found: ${normalizeTaskRef(taskRef)}. Check docs/tasks/.`;
+    }
+    return "No open TASK found. Run `vibeops task add` or pass `vibeops task done TASK-NNN`.";
+}

package/dist/lib/task-add-llm.js

@@ -1,59 +1,13 @@
 import { join, relative } from "node:path";
 import { readTextOrNull } from "./filesystem.js";
+import { readConfig } from "./config.js";
 import { llmCompleteJson } from "./llm-complete.js";
-import { bold, dim, log } from "./logger.js";
-import { askInput, askSelect, yesNoSelect } from "./inquirer-helpers.js";
-import { pickPlanLlmProvider } from "./plan-llm-session.js";
-import { extractJsonObject } from "./plan-llm-openai.js";
+import { getLlmPreferenceFromConfig } from "./llm-preference.js";
 import { projectPaths } from "./paths.js";
 import { slugify } from "./slug.js";
-import { buildTaskBuildPrompt } from "./task-add-build-prompt.js";
+import { buildMinimalTaskMarkdown, ensureV3Sections, normalizeTaskHeader, titleFromIdea, } from "./task-scaffold.js";
 import { statusDisplay } from "./task.js";
-const MAX_PLAN_TURNS = 36;
-const REQUIRED_SECTIONS = [
-    "Status",
-    "MVP Phase",
-    "Goal",
-    "Background",
-    "Scope",
-    "Out of Scope",
-    "Acceptance Criteria",
-    "Files to Inspect First",
-    "Expected Files to Change",
-    "Risks",
-    "Test Plan",
-    "Rollback Plan",
-    "Implementation Plan",
-    "Result",
-    "Test Result",
-];
-function parseTaskPlanTurn(jsonText) {
-    const raw = JSON.parse(jsonText);
-    const turn = raw.turn;
-    if (turn === "done") {
-        const taskMarkdown = typeof raw.taskMarkdown === "string" ? raw.taskMarkdown.trim() : "";
-        const buildPromptMarkdown = typeof raw.buildPromptMarkdown === "string" ? raw.buildPromptMarkdown.trim() : "";
-        if (taskMarkdown.length === 0) {
-            throw new Error('Invalid JSON: "done" needs non-empty "taskMarkdown".');
-        }
-        if (buildPromptMarkdown.length === 0) {
-            throw new Error('Invalid JSON: "done" needs non-empty "buildPromptMarkdown".');
-        }
-        return { turn: "done", taskMarkdown, buildPromptMarkdown };
-    }
-    if (turn === "question") {
-        const message = typeof raw.message === "string" ? raw.message.trim() : "";
-        if (message.length === 0)
-            throw new Error('Invalid JSON: "question" needs "message".');
-        const kindRaw = typeof raw.inputKind === "string" ? raw.inputKind : "text";
-        const inputKind = kindRaw === "select" || kindRaw === "confirm" ? kindRaw : "text";
-        const options = Array.isArray(raw.options)
-            ? raw.options.filter((x) => typeof x === "string")
-            : undefined;
-        return { turn: "question", message, inputKind, options };
-    }
-    throw new Error('LLM JSON must use turn "question" or "done".');
-}
+import { extractJsonObject } from "./plan-llm-openai.js";
 async function readSnippet(absPath, maxChars) {
     const text = await readTextOrNull(absPath);
     if (text === null)
@@ -61,208 +15,74 @@ async function readSnippet(absPath, maxChars) {
     const t = text.trim();
     return t.length <= maxChars ? t : `${t.slice(0, maxChars)}\n…`;
 }
-export async function loadTaskAddProjectContext(cwd) {
+export async function loadProjectContextForLlm(cwd) {
     const paths = projectPaths(cwd);
-    const chunks = [];
     const candidates = [
         join(paths.docsProject, "05-current-state.md"),
-        join(paths.docsProject, "03-current-state.md"),
-        join(paths.docsProject, "02-mvp-scope.md"),
         join(paths.docsProject, "03-architecture.md"),
-        join(paths.docsProject, "04-tech-stack.md"),
         join(paths.docsProject, "06-decisions.md"),
     ];
+    const chunks = [];
     for (const p of candidates) {
-        const snip = await readSnippet(p, 3500);
-        if (snip) {
+        const snip = await readSnippet(p, 3000);
+        if (snip)
             chunks.push(`### ${relative(cwd, p)}\n\n${snip}`);
-        }
     }
-    return chunks.length > 0 ? chunks.join("\n\n") : "(no docs/project context files found)";
+    return chunks.length > 0 ? chunks.join("\n\n") : "(no project docs yet)";
 }
-function quickTaskSystemPrompt() {
-    return `You are a VibeOps TASK author. Respond with JSON only (no markdown fence).
+function systemPrompt() {
+    return `You are a VibeOps TASK author. Reply with JSON only.
 
-Schema:
 {
-  "title": "short title without TASK- id prefix",
-  "slug": "kebab-case-slug-max-60-chars-no-task-prefix",
-  "markdown": "full TASK markdown file"
+  "title": "short title without TASK- id",
+  "slug": "kebab-case-max-60-chars",
+  "markdown": "full TASK markdown"
 }
 
-The markdown file must:
-- Start with # TASK-NNN: title (use the exact TASK id provided)
-- Include every section: ${REQUIRED_SECTIONS.join(", ")}
-- Status body: ${statusDisplay("planned")}
-- Result and Test Result: (not yet)
-- Keep Scope and Acceptance Criteria minimal but valid — the human will edit heavily in Cursor
-- Do not invent TASK numbers other than the one given`;
-}
-function taskPlanSystemPrompt(taskId, projectName) {
-    return `You are a VibeOps TASK planner. Interview the user, then produce a complete TASK and a Cursor build prompt.
-
-Respond with JSON only (no markdown fence).
-
-Turn "question":
-{
-  "turn": "question",
-  "message": "…",
-  "inputKind": "text" | "select" | "confirm",
-  "options": ["…"]  // required for select; optional for confirm (Yes/No implied)
-}
-
-Turn "done":
-{
-  "turn": "done",
-  "taskMarkdown": "full TASK file for ${taskId}",
-  "buildPromptMarkdown": "markdown for Cursor — implement ${taskId} per the TASK"
-}
-
-taskMarkdown rules:
-- # ${taskId}: … as first line
-- All sections: ${REQUIRED_SECTIONS.join(", ")}
-- Status: ${statusDisplay("planned")}; Result / Test Result: (not yet)
-- Acceptance Criteria numbered and verifiable
-- Align with docs/project; put out-of-MVP items in Out of Scope
-
-buildPromptMarkdown rules:
-- Standalone implementer brief for Cursor (like mvp-build.md)
-- Reference the TASK path; list read-first docs; definition of done
-- Project: ${projectName}
-
-Ask enough questions to nail Scope, Acceptance Criteria, and Test Plan. Then finish with "done".`;
-}
-function parseQuickTaskJson(jsonText) {
-    const raw = JSON.parse(jsonText);
-    const title = typeof raw.title === "string" ? raw.title.trim() : "";
-    const slug = typeof raw.slug === "string" ? slugify(raw.slug, "task") : "";
-    const markdown = typeof raw.markdown === "string" ? raw.markdown.trim() : "";
-    if (title.length === 0)
-        throw new Error('LLM JSON missing "title".');
-    if (markdown.length === 0)
-        throw new Error('LLM JSON missing "markdown".');
-    return { title, slug: slug.length > 0 ? slug : slugify(title), markdown };
+markdown must include sections: Status, Goal, Scope, Out of Scope, Acceptance Criteria, Test Plan, Git Context, Result, Test Result.
+Status body: ${statusDisplay("planned")}
+Result and Test Result: (not yet)
+Git Context: (populated by vibeops task add)
+Use the exact TASK id given in the user message for the # heading.`;
 }
-export function normalizeTaskMarkdownHeader(markdown, taskId, title) {
-    const lines = markdown.split("\n");
-    const header = `# ${taskId}: ${title}`;
-    if (lines.length > 0 && /^#\s+/.test(lines[0])) {
-        lines[0] = header;
-        return lines.join("\n");
-    }
-    return `${header}\n\n${markdown}`;
-}
-export function ensureTaskSections(markdown) {
-    let body = markdown;
-    for (const section of REQUIRED_SECTIONS) {
-        const re = new RegExp(`^##\\s+${section.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*$`, "im");
-        if (!re.test(body)) {
-            body = `${body.trimEnd()}\n\n## ${section}\n\n(not yet)\n`;
-        }
-    }
-    return body;
-}
-async function collectTaskPlanAnswer(q) {
-    if (q.inputKind === "confirm") {
-        const yes = await yesNoSelect({ message: q.message, defaultValue: true });
-        return yes ? "Yes" : "No";
-    }
-    if (q.inputKind === "select" && q.options && q.options.length > 0) {
-        return await askSelect({
-            message: q.message,
-            nonInteractive: false,
-            choices: q.options,
-            default: q.options[0],
+export async function llmScaffoldTask(params) {
+    try {
+        const context = await loadProjectContextForLlm(params.cwd);
+        const messages = [
+            { role: "system", content: systemPrompt() },
+            {
+                role: "user",
+                content: [`TASK id: ${params.taskId}`, `Idea: ${params.idea}`, "", context].join("\n"),
+            },
+        ];
+        const config = await readConfig(params.cwd);
+        const preference = getLlmPreferenceFromConfig(config);
+        const { text: raw, provider } = await llmCompleteJson(messages, {
+            cwd: params.cwd,
+            preference,
         });
+        const parsed = JSON.parse(extractJsonObject(raw));
+        const title = typeof parsed.title === "string"
+            ? parsed.title.replace(/^TASK-\d+\s*[:\-]\s*/i, "").trim()
+            : "";
+        const slug = typeof parsed.slug === "string" ? slugify(parsed.slug, "task") : slugify(title, "task");
+        const markdown = typeof parsed.markdown === "string" ? parsed.markdown.trim() : "";
+        if (title.length === 0 || markdown.length === 0)
+            return null;
+        const body = ensureV3Sections(normalizeTaskHeader(markdown, params.taskId, title));
+        return { title, slug, markdown: body, provider };
     }
-    return await askInput({ message: q.message, nonInteractive: false, required: true });
-}
-export async function llmGenerateQuickTask(params) {
-    const provider = await pickPlanLlmProvider(params.cwd, undefined, { interactiveLogin: false });
-    if (provider === null)
+    catch {
         return null;
-    const context = await loadTaskAddProjectContext(params.cwd);
-    const latest = params.latestDone !== undefined && params.latestDone !== null
-        ? `Latest done TASK: ${params.latestDone.id} — ${params.latestDone.title}`
-        : "";
-    const messages = [
-        { role: "system", content: quickTaskSystemPrompt() },
-        {
-            role: "user",
-            content: [
-                `TASK id: ${params.taskId}`,
-                `User intent: ${params.idea}`,
-                latest,
-                "",
-                "Project context:",
-                context,
-            ]
-                .filter((l) => l.length > 0)
-                .join("\n"),
-        },
-    ];
-    const { text: raw, provider: used } = await llmCompleteJson(messages, { cwd: params.cwd, provider });
-    const parsed = parseQuickTaskJson(extractJsonObject(raw));
-    const title = parsed.title.replace(/^TASK-\d+\s*[·:\-]\s*/i, "").trim() || parsed.title;
-    const markdown = ensureTaskSections(normalizeTaskMarkdownHeader(parsed.markdown, params.taskId, title));
+    }
+}
+export function fallbackTaskDraft(taskId, idea) {
+    const title = titleFromIdea(idea);
+    const draft = { id: taskId, title, idea };
+    const slug = slugify(title);
     return {
         title,
-        slug: parsed.slug,
-        markdown,
-        provider: used,
+        slug,
+        markdown: ensureV3Sections(normalizeTaskHeader(buildMinimalTaskMarkdown(draft), taskId, title)),
     };
 }
-export async function gatherTaskPlanViaLlm(params) {
-    const provider = await pickPlanLlmProvider(params.cwd, undefined, { interactiveLogin: true });
-    if (provider === null)
-        return null;
-    const context = await loadTaskAddProjectContext(params.cwd);
-    const messages = [
-        { role: "system", content: taskPlanSystemPrompt(params.taskId, params.projectName) },
-        {
-            role: "user",
-            content: [
-                `TASK id: ${params.taskId}`,
-                params.seedIdea ? `Initial idea: ${params.seedIdea}` : "Ask what the user wants to build.",
-                "",
-                "Project context:",
-                context,
-                "",
-                "Begin with your first question JSON.",
-            ].join("\n"),
-        },
-    ];
-    let lastQ = "";
-    for (let step = 0; step < MAX_PLAN_TURNS; step++) {
-        const { text: raw, provider: used } = await llmCompleteJson(messages, {
-            cwd: params.cwd,
-            provider,
-        });
-        const parsed = parseTaskPlanTurn(extractJsonObject(raw));
-        if (parsed.turn === "done") {
-            const titleMatch = /^#\s+TASK-\d+:\s*(.+)$/m.exec(parsed.taskMarkdown);
-            const title = titleMatch?.[1]?.trim() ?? params.taskId;
-            const markdown = ensureTaskSections(normalizeTaskMarkdownHeader(parsed.taskMarkdown, params.taskId, title));
-            return {
-                markdown,
-                buildPromptMarkdown: parsed.buildPromptMarkdown,
-                provider: used,
-            };
-        }
-        log.blank();
-        log.info(dim(`Planning ${params.taskId} — question ${step + 1}`));
-        log.info(bold(parsed.message));
-        log.blank();
-        const answer = await collectTaskPlanAnswer(parsed);
-        lastQ = parsed.message;
-        messages.push({ role: "assistant", content: raw });
-        messages.push({
-            role: "user",
-            content: `Previous Q: ${lastQ}\nUser answer: ${answer}\n\nContinue with next JSON (question or done).`,
-        });
-    }
-    throw new Error(`Task planning stopped after ${MAX_PLAN_TURNS} turns — try a shorter scope or run again.`);
-}
-export function defaultBuildPromptForTask(projectName, taskId, taskRelativePath) {
-    return buildTaskBuildPrompt({ projectName, taskId, taskRelativePath });
-}

package/dist/lib/task-context.js

@@ -0,0 +1,68 @@
+import { relative } from "node:path";
+import { gitBranchExists, readGitInfo } from "./git.js";
+import { readGitContext } from "./task.js";
+import { isOnTaskBranch, loadActionableTasks, pickActiveTask, pickInProgressTask, } from "./task.js";
+/** TASK that blocks `task add` — in progress or open on current task branch. */
+export async function findBlockingTask(paths, cwd) {
+    const tasks = await loadActionableTasks(paths.docsTasks);
+    const inProgress = pickInProgressTask(tasks);
+    if (inProgress !== null)
+        return inProgress;
+    const git = await readGitInfo(cwd);
+    if (git.isRepo && typeof git.branch === "string" && git.branch.startsWith("task/")) {
+        for (const t of tasks) {
+            if (t.status === "done")
+                continue;
+            const ctx = await readGitContext(t.filePath);
+            if (isOnTaskBranch(git.branch, ctx))
+                return t;
+        }
+    }
+    return null;
+}
+export async function pickFocusTask(paths, cwd) {
+    return pickActiveTask(paths.docsTasks, cwd);
+}
+export function relPath(cwd, filePath) {
+    const r = relative(cwd, filePath).replace(/\\/g, "/");
+    return r.startsWith("..") ? filePath : r;
+}
+export function computeNextHint(input) {
+    if (!input.isVibeopsProject)
+        return "init";
+    if (input.focus === null)
+        return "task-add";
+    if (input.focus.status === "done")
+        return "task-add";
+    if (!input.resultFilled || !input.testFilled) {
+        return input.onTaskBranch === true ? "cursor-implement" : "cursor-plan";
+    }
+    return "task-done";
+}
+export function hintToText(hint, cwd, task) {
+    switch (hint) {
+        case "init":
+            return "Run `vibeops init` in this directory.";
+        case "task-add":
+            return "Run `vibeops task add` to start the next slice.";
+        case "task-done":
+            return task ? `Run \`vibeops task done ${task.id}\`.` : "Run `vibeops task done`.";
+        case "cursor-plan":
+            return task
+                ? `In Cursor Ask: @${relPath(cwd, task.filePath)} — refine Scope / AC.`
+                : "Open the TASK file in Cursor Ask.";
+        case "cursor-implement":
+            return task
+                ? `In Cursor Agent: @${relPath(cwd, task.filePath)} — implement, then task done.`
+                : "Implement per the TASK file in Cursor.";
+    }
+}
+export async function listInProgressTasks(paths) {
+    return (await loadActionableTasks(paths.docsTasks)).filter((t) => t.status === "in_progress");
+}
+export async function taskBranchExistsFor(cwd, task) {
+    const ctx = await readGitContext(task.filePath);
+    if (ctx === null)
+        return false;
+    return gitBranchExists(cwd, ctx.taskBranch);
+}

package/dist/lib/task-done-llm.js

@@ -0,0 +1,155 @@
+import { join } from "node:path";
+import { readText, readTextOrNull, writeText } from "./filesystem.js";
+import { readConfig } from "./config.js";
+import { llmCompleteJson } from "./llm-complete.js";
+import { getLlmPreferenceFromConfig } from "./llm-preference.js";
+import { gitDiffNameOnly, readGitInfo } from "./git.js";
+import { projectPaths, PROJECT_MEMORY_FILES } from "./paths.js";
+import { extractJsonObject } from "./plan-llm-openai.js";
+import { readSection, updateTaskSection } from "./task.js";
+function localDateFilename() {
+    const d = new Date();
+    const y = d.getFullYear();
+    const m = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    return `${y}-${m}-${day}.md`;
+}
+async function readOptional(path) {
+    return readTextOrNull(path);
+}
+export async function llmCompleteTaskDone(params) {
+    const git = await readGitInfo(params.cwd);
+    let diffSummary = "";
+    if (git.isRepo) {
+        const names = await gitDiffNameOnly(params.cwd);
+        diffSummary = names.slice(0, 40).join("\n") || "(no diff vs HEAD index yet)";
+    }
+    const paths = projectPaths(params.cwd);
+    const currentState = (await readOptional(join(paths.root, PROJECT_MEMORY_FILES.currentState))) ?? "";
+    const architecture = (await readOptional(join(paths.root, PROJECT_MEMORY_FILES.architecture))) ?? "";
+    const decisions = (await readOptional(join(paths.root, PROJECT_MEMORY_FILES.decisions))) ?? "";
+    const messages = [
+        {
+            role: "system",
+            content: `You close a VibeOps TASK. Reply with JSON only:
+{
+  "result": "markdown for TASK Result section — facts, paths, commands",
+  "testResult": "markdown for Test Result — commands and outcomes",
+  "currentStateMarkdown": "full replacement for docs/project/05-current-state.md OR null to skip",
+  "decisionsAppend": "markdown bullets to append under ## Decisions in 06-decisions.md OR null",
+  "architectureUpdate": "full replacement for 03-architecture.md OR null if structure unchanged",
+  "logLine": "one line for docs/logs/YYYY-MM-DD.md"
+}
+Be factual. Do not invent files not in the diff.`,
+        },
+        {
+            role: "user",
+            content: [
+                `TASK: ${params.taskId} — ${params.taskTitle}`,
+                `File: ${params.taskFileRel}`,
+                "",
+                "TASK body:",
+                params.taskBody.slice(0, 8000),
+                "",
+                "Changed paths (git):",
+                diffSummary,
+                "",
+                "Current 05-current-state.md:",
+                currentState.slice(0, 4000),
+                "",
+                "Current 03-architecture.md:",
+                architecture.slice(0, 4000),
+                "",
+                "Current 06-decisions.md:",
+                decisions.slice(0, 2000),
+            ].join("\n"),
+        },
+    ];
+    try {
+        const config = await readConfig(params.cwd);
+        const preference = getLlmPreferenceFromConfig(config);
+        const { text: raw, provider } = await llmCompleteJson(messages, {
+            cwd: params.cwd,
+            preference,
+        });
+        const parsed = JSON.parse(extractJsonObject(raw));
+        const result = typeof parsed.result === "string" ? parsed.result.trim() : "";
+        const testResult = typeof parsed.testResult === "string" ? parsed.testResult.trim() : "";
+        if (result.length === 0 || testResult.length === 0)
+            return null;
+        return {
+            result,
+            testResult,
+            currentStateMarkdown: typeof parsed.currentStateMarkdown === "string" && parsed.currentStateMarkdown.trim().length > 0
+                ? parsed.currentStateMarkdown.trim()
+                : null,
+            decisionsAppend: typeof parsed.decisionsAppend === "string" && parsed.decisionsAppend.trim().length > 0
+                ? parsed.decisionsAppend.trim()
+                : null,
+            architectureUpdate: typeof parsed.architectureUpdate === "string" && parsed.architectureUpdate.trim().length > 0
+                ? parsed.architectureUpdate.trim()
+                : null,
+            logLine: typeof parsed.logLine === "string" && parsed.logLine.trim().length > 0
+                ? parsed.logLine.trim()
+                : `${params.taskId} done.`,
+            provider,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function applyTaskDoneMemory(cwd, patch) {
+    const paths = projectPaths(cwd);
+    const updated = [];
+    const skipped = [];
+    if (patch.currentStateMarkdown) {
+        const p = join(paths.root, PROJECT_MEMORY_FILES.currentState);
+        await writeText(p, `${patch.currentStateMarkdown.trimEnd()}\n`);
+        updated.push(PROJECT_MEMORY_FILES.currentState);
+    }
+    else {
+        skipped.push(PROJECT_MEMORY_FILES.currentState);
+    }
+    if (patch.architectureUpdate) {
+        const p = join(paths.root, PROJECT_MEMORY_FILES.architecture);
+        await writeText(p, `${patch.architectureUpdate.trimEnd()}\n`);
+        updated.push(PROJECT_MEMORY_FILES.architecture);
+    }
+    else {
+        skipped.push(PROJECT_MEMORY_FILES.architecture);
+    }
+    if (patch.decisionsAppend) {
+        const p = join(paths.root, PROJECT_MEMORY_FILES.decisions);
+        const existing = (await readOptional(p)) ?? "# Decisions\n\n";
+        const next = `${existing.trimEnd()}\n\n${patch.decisionsAppend.trim()}\n`;
+        await writeText(p, next);
+        updated.push(PROJECT_MEMORY_FILES.decisions);
+    }
+    else {
+        skipped.push(PROJECT_MEMORY_FILES.decisions);
+    }
+    const logPath = join(paths.docsLogs, localDateFilename());
+    const logExisting = (await readOptional(logPath)) ?? `# ${localDateFilename().replace(".md", "")}\n\n`;
+    await writeText(logPath, `${logExisting.trimEnd()}\n\n- ${patch.logLine}\n`);
+    updated.push(relativeLogPath(logPath, paths.root));
+    return { updated, skipped };
+}
+function relativeLogPath(abs, root) {
+    return abs.startsWith(root) ? abs.slice(root.length + 1) : abs;
+}
+export async function writeTaskResultSections(taskFile, result, testResult) {
+    await updateTaskSection(taskFile, "Result", result);
+    await updateTaskSection(taskFile, "Test Result", testResult);
+}
+/** Minimal fallback when LLM unavailable — git-only sections from diff. */
+export async function fallbackResultSections(cwd, taskId, taskFile) {
+    const names = await gitDiffNameOnly(cwd);
+    const body = await readText(taskFile);
+    const goal = readSection(body, "Goal").slice(0, 200);
+    const result = [`Completed ${taskId}.`, goal.length > 0 ? `Goal: ${goal}` : "", names.length > 0 ? `Paths: ${names.slice(0, 15).join(", ")}` : ""]
+        .filter((l) => l.length > 0)
+        .join("\n");
+    const testResult = names.length > 0 ? `Changed: ${names.join(", ")}` : "Manual verification required.";
+    return { result, testResult };
+}