@opengsd/gsd-pi 1.7.0 → 1.8.1-dev.897b3c90

package/dist/resources/extensions/gsd/tools/rework-brief.js

@@ -0,0 +1,74 @@
+import { saveReworkBrief } from "../gsd-db.js";
+import { isNonEmptyString, validateStringArray } from "../validation.js";
+function validateFinding(finding, index) {
+    if (!isNonEmptyString(finding?.findingId))
+        throw new Error(`findings[${index}].findingId is required`);
+    if (finding.severity !== "blocking" && finding.severity !== "advisory") {
+        throw new Error(`findings[${index}].severity must be blocking or advisory`);
+    }
+    if (!isNonEmptyString(finding.description))
+        throw new Error(`findings[${index}].description is required`);
+    if (!isNonEmptyString(finding.requiredFix))
+        throw new Error(`findings[${index}].requiredFix is required`);
+    const status = finding.status ?? "pending";
+    if (status !== "pending" && status !== "resolved" && status !== "deferred-with-override") {
+        throw new Error(`findings[${index}].status must be pending, resolved, or deferred-with-override`);
+    }
+    // A blocking finding is only enforced by gsd_task_complete while it is
+    // `pending` (getUnresolvedBlockingReworkFindingsForTask returns pending rows
+    // only). Persisting a blocking finding as resolved/deferred-with-override
+    // at save time therefore bypasses the completion gate entirely, so require
+    // the same justification a reworkResolution would (evidence for `resolved`,
+    // evidence + decisionRef for `deferred-with-override`). Advisory findings do
+    // not gate completion, so their status is left as-is.
+    if (finding.severity === "blocking" && status !== "pending") {
+        if (!isNonEmptyString(finding.evidence)) {
+            throw new Error(`findings[${index}].evidence is required when a blocking finding is saved as ${status}`);
+        }
+        if (status === "deferred-with-override" && !isNonEmptyString(finding.decisionRef)) {
+            throw new Error(`findings[${index}].decisionRef is required when a blocking finding is saved as deferred-with-override`);
+        }
+    }
+    return {
+        ...finding,
+        verificationCommands: validateStringArray(finding.verificationCommands, `findings[${index}].verificationCommands`),
+        status,
+    };
+}
+function validateParams(params) {
+    if (!isNonEmptyString(params?.milestoneId))
+        throw new Error("milestoneId is required");
+    if (!isNonEmptyString(params?.sliceId))
+        throw new Error("sliceId is required");
+    if (!isNonEmptyString(params?.taskId))
+        throw new Error("taskId is required");
+    if (!Array.isArray(params.findings) || params.findings.length === 0) {
+        throw new Error("findings must be a non-empty array");
+    }
+    return {
+        ...params,
+        findings: params.findings.map(validateFinding),
+    };
+}
+export async function handleReworkBriefSave(rawParams) {
+    let params;
+    try {
+        params = validateParams(rawParams);
+    }
+    catch (err) {
+        return { error: `validation failed: ${err.message}` };
+    }
+    try {
+        const { briefId } = saveReworkBrief(params);
+        return {
+            briefId,
+            milestoneId: params.milestoneId,
+            sliceId: params.sliceId,
+            taskId: params.taskId,
+            findingCount: params.findings.length,
+        };
+    }
+    catch (err) {
+        return { error: `db write failed: ${err.message}` };
+    }
+}

package/dist/resources/extensions/gsd/tools/workflow-tool-executors.js

@@ -18,6 +18,8 @@ import { handleCompleteSlice } from "./complete-slice.js";
 import { handlePlanMilestone } from "./plan-milestone.js";
 import { handlePlanSlice } from "./plan-slice.js";
 import { handleReplanSlice } from "./replan-slice.js";
+import { handleReplanTask } from "./replan-task.js";
+import { handleReworkBriefSave } from "./rework-brief.js";
 import { handleReopenMilestone } from "./reopen-milestone.js";
 import { handleReopenSlice } from "./reopen-slice.js";
 import { handleReopenTask } from "./reopen-task.js";
@@ -1277,6 +1279,85 @@ export async function executePlanSlice(params, basePath = process.cwd()) {
         };
     }
 }
+export async function executeReplanTask(params, basePath = process.cwd()) {
+    const dbAvailable = await ensureDbOpen(basePath);
+    if (!dbAvailable) {
+        return {
+            content: [{ type: "text", text: "Error: GSD database is not available. Cannot replan task." }],
+            details: { operation: "replan_task", error: "db_unavailable" },
+            isError: true,
+        };
+    }
+    try {
+        const result = await handleReplanTask(params, basePath);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: `Error replanning task: ${result.error}` }],
+                details: { operation: "replan_task", error: result.error },
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: `Replanned task ${result.taskId} (${result.sliceId}/${result.milestoneId})` }],
+            details: {
+                operation: "replan_task",
+                milestoneId: result.milestoneId,
+                sliceId: result.sliceId,
+                taskId: result.taskId,
+                taskPlanPath: result.taskPlanPath,
+            },
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logError("tool", `replan_task tool failed: ${msg}`, { tool: "gsd_replan_task", error: String(err) });
+        return {
+            content: [{ type: "text", text: `Error replanning task: ${msg}` }],
+            details: { operation: "replan_task", error: msg },
+            isError: true,
+        };
+    }
+}
+export async function executeReworkBriefSave(params, basePath = process.cwd()) {
+    const dbAvailable = await ensureDbOpen(basePath);
+    if (!dbAvailable) {
+        return {
+            content: [{ type: "text", text: "Error: GSD database is not available. Cannot save rework brief." }],
+            details: { operation: "rework_brief_save", error: "db_unavailable" },
+            isError: true,
+        };
+    }
+    try {
+        const result = await handleReworkBriefSave(params);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: `Error saving rework brief: ${result.error}` }],
+                details: { operation: "rework_brief_save", error: result.error },
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: `Saved rework brief ${result.briefId} with ${result.findingCount} finding(s)` }],
+            details: {
+                operation: "rework_brief_save",
+                briefId: result.briefId,
+                milestoneId: result.milestoneId,
+                sliceId: result.sliceId,
+                taskId: result.taskId,
+                findingCount: result.findingCount,
+            },
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logError("tool", `rework_brief_save tool failed: ${msg}`, { tool: "gsd_rework_brief_save", error: String(err) });
+        return {
+            content: [{ type: "text", text: `Error saving rework brief: ${msg}` }],
+            details: { operation: "rework_brief_save", error: msg },
+            isError: true,
+        };
+    }
+}
 export async function executeReplanSlice(params, basePath = process.cwd()) {
     const dbAvailable = await ensureDbOpen(basePath);
     if (!dbAvailable) {

package/dist/resources/extensions/gsd/unit-registry.js

@@ -232,6 +232,8 @@ export const UNIT_REGISTRY = {
                 "gsd_slice_complete",
                 "gsd_task_reopen",
                 "gsd_replan_slice",
+                "gsd_replan_task",
+                "gsd_rework_brief_save",
                 "gsd_decision_save",
                 "gsd_capture_thought",
                 "gsd_requirement_update",
@@ -245,6 +247,8 @@ export const UNIT_REGISTRY = {
                 "gsd_slice_complete",
                 "gsd_task_reopen",
                 "gsd_replan_slice",
+                "gsd_replan_task",
+                "gsd_rework_brief_save",
                 "gsd_requirement_update",
                 "gsd_summary_save",
             ],

package/dist/resources/extensions/gsd/uok/plan-v2.js

@@ -3,7 +3,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot, resolveMilestoneFile, resolveSliceFile } from "../paths.js";
-import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "../gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getTasksBySliceIds } from "../gsd-db.js";
 const PLAN_V2_CLARIFY_ROUND_LIMIT = 3;
 export const EXECUTION_ENTRY_PHASES = new Set([
     "executing",
@@ -17,6 +17,19 @@ export function isExecutionEntryPhase(phase) {
 function graphOutputPath(basePath) {
     return join(gsdRoot(basePath), "runtime", "uok-plan-v2-graph.json");
 }
+// True when the on-disk graph matches `output` ignoring the volatile `compiledAt`
+// stamp, so redundant recompiles on the dispatch hot path skip the disk write.
+function graphBodyUnchanged(outPath, output) {
+    try {
+        const existing = JSON.parse(readFileSync(outPath, "utf-8"));
+        const { compiledAt: _existingStamp, ...existingBody } = existing;
+        const { compiledAt: _outputStamp, ...outputBody } = output;
+        return JSON.stringify(existingBody) === JSON.stringify(outputBody);
+    }
+    catch {
+        return false; // Missing, unreadable, or corrupt — write.
+    }
+}
 function hasFileContent(path) {
     if (!path || !existsSync(path))
         return false;
@@ -88,9 +101,10 @@ export function compileUnitGraphFromState(basePath, state) {
             finalizedContextIncluded,
         };
     }
+    const tasksBySlice = getTasksBySliceIds(slices.map((slice) => ({ milestoneId: mid, sliceId: slice.id })));
     for (const slice of slices) {
         const sid = slice.id;
-        const tasks = getSliceTasks(mid, sid)
+        const tasks = (tasksBySlice.get(`${mid}\0${sid}`) ?? [])
             .sort((a, b) => Number(a.sequence ?? 0) - Number(b.sequence ?? 0));
         let previousTaskNodeId = null;
         for (const task of tasks) {
@@ -138,7 +152,9 @@ export function compileUnitGraphFromState(basePath, state) {
     };
     const outPath = graphOutputPath(basePath);
     mkdirSync(join(gsdRoot(basePath), "runtime"), { recursive: true });
-    writeFileSync(outPath, JSON.stringify(output, null, 2) + "\n", "utf-8");
+    if (!graphBodyUnchanged(outPath, output)) {
+        writeFileSync(outPath, JSON.stringify(output, null, 2) + "\n", "utf-8");
+    }
     return {
         ok: true,
         graphPath: outPath,

package/dist/resources/extensions/gsd/worktree-state-projection.js

@@ -143,6 +143,9 @@ function syncOtherMilestoneArtifacts(srcMilestonesDir, dstMilestonesDir, current
         logWarning("worktree", `milestone artifact scan failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
+function syncFlatPhaseArtifacts(prGsd, wtGsd) {
+    safeCopyRecursive(join(prGsd, "phases"), join(wtGsd, "phases"), { force: false });
+}
 /**
  * Root-level .gsd/ files copied from worktree back to project root for
  * post-merge diagnostics. Markdown projections are NOT in this list — DB
@@ -208,6 +211,9 @@ export function _projectRootToWorktreeImpl(projectRoot, worktreePath_, milestone
     // Root PROJECT/REQUIREMENTS/DECISIONS projections must be readable from a
     // worktree-bound unit; the project root remains authoritative.
     syncRootProjectionFilesToWorktree(prGsd, wtGsd);
+    // Flat-phase artifacts (phases/NN-slug/NN-CONTEXT.md, NN-DISCUSSION.md,
+    // ROADMAP, etc.) must be available before the first worktree dispatch.
+    syncFlatPhaseArtifacts(prGsd, wtGsd);
     // Copy milestone directory from project root to worktree — additive only.
     // force:false prevents cpSync from overwriting existing worktree files.
     // Without this, worktree-local files (e.g. VALIDATION.md written

package/dist/resources/extensions/mac-tools/index.js

@@ -15,6 +15,7 @@ import { StringEnum, Type } from "@gsd/pi-ai";
 import { execFileSync } from "node:child_process";
 import { statSync, readdirSync } from "node:fs";
 import path from "node:path";
+import { constrainScreenshot, getScreenshotBufferDimensions, } from "../browser-tools/screenshot-constraints.js";
 // ---------------------------------------------------------------------------
 // Paths
 // ---------------------------------------------------------------------------
@@ -79,6 +80,27 @@ function ensureCompiled() {
         throw new Error(`Swift compilation failed (${action.toLowerCase()}):\n${stderr || stdout || err.message}`);
     }
 }
+function macScreenshotQualityToPercent(quality) {
+    if (quality === undefined || !Number.isFinite(quality))
+        return 80;
+    return Math.min(100, Math.max(1, Math.round(quality * 100)));
+}
+export async function prepareMacScreenshotPayload(data, quality) {
+    const format = data.format;
+    const mimeType = format === "png" ? "image/png" : "image/jpeg";
+    const rawBuffer = Buffer.from(data.imageData, "base64");
+    const constrainedBuffer = await constrainScreenshot(null, rawBuffer, mimeType, macScreenshotQualityToPercent(quality));
+    const dimensions = constrainedBuffer === rawBuffer
+        ? null
+        : await getScreenshotBufferDimensions(constrainedBuffer);
+    return {
+        imageData: constrainedBuffer.toString("base64"),
+        width: dimensions?.width ?? data.width,
+        height: dimensions?.height ?? data.height,
+        format,
+        mimeType,
+    };
+}
 /**
  * Invoke the mac-agent CLI with a command and optional params.
  * Handles compilation caching, stdin/stdout JSON protocol, and error surfacing.
@@ -646,18 +668,18 @@ export default function (pi) {
             if (!result.success) {
                 throw new Error("mac_screenshot: " + result.error);
             }
-            const data = result.data;
-            const imageData = data.imageData;
-            const format = data.format;
-            const width = data.width;
-            const height = data.height;
-            const mimeType = format === "png" ? "image/png" : "image/jpeg";
+            const screenshot = await prepareMacScreenshotPayload(result.data, args.quality);
             return {
                 content: [
-                    { type: "text", text: `Screenshot: ${width}x${height} ${format}` },
-                    { type: "image", data: imageData, mimeType },
+                    { type: "text", text: `Screenshot: ${screenshot.width}x${screenshot.height} ${screenshot.format}` },
+                    { type: "image", data: screenshot.imageData, mimeType: screenshot.mimeType },
                 ],
-                details: { width, height, format, mimeType },
+                details: {
+                    width: screenshot.width,
+                    height: screenshot.height,
+                    format: screenshot.format,
+                    mimeType: screenshot.mimeType,
+                },
             };
         },
     });