@opengsd/gsd-pi 1.8.1 → 1.9.0

package/src/resources/extensions/gsd/tools/workflow-tool-executors.ts

@@ -37,6 +37,10 @@ import type { PlanSliceParams } from "./plan-slice.js";
 import { handlePlanSlice } from "./plan-slice.js";
 import type { ReplanSliceParams } from "./replan-slice.js";
 import { handleReplanSlice } from "./replan-slice.js";
+import type { ReplanTaskParams } from "./replan-task.js";
+import { handleReplanTask } from "./replan-task.js";
+import type { ReworkBriefSaveParams } from "./rework-brief.js";
+import { handleReworkBriefSave } from "./rework-brief.js";
 import type { ReopenMilestoneParams } from "./reopen-milestone.js";
 import { handleReopenMilestone } from "./reopen-milestone.js";
 import type { ReopenSliceParams } from "./reopen-slice.js";
@@ -696,6 +700,8 @@ export type SliceCompleteExecutorParams = CompleteSliceParams;
 export type PlanMilestoneExecutorParams = PlanMilestoneParams;
 export type PlanSliceExecutorParams = PlanSliceParams;
 export type ReplanSliceExecutorParams = ReplanSliceParams;
+export type ReplanTaskExecutorParams = ReplanTaskParams;
+export type ReworkBriefSaveExecutorParams = ReworkBriefSaveParams;
 export type ReopenTaskExecutorParams = ReopenTaskParams;
 export type ReopenSliceExecutorParams = ReopenSliceParams;
 export type ReopenMilestoneExecutorParams = ReopenMilestoneParams;
@@ -1490,6 +1496,92 @@ export async function executePlanSlice(
   }
 }
 
+
+export async function executeReplanTask(
+  params: ReplanTaskExecutorParams,
+  basePath: string = process.cwd(),
+): Promise<ToolExecutionResult> {
+  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: ReworkBriefSaveExecutorParams,
+  basePath: string = process.cwd(),
+): Promise<ToolExecutionResult> {
+  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: ReplanSliceExecutorParams,
   basePath: string = process.cwd(),

package/src/resources/extensions/gsd/types.ts

@@ -695,6 +695,17 @@ export interface CompleteTaskParams {
     verdict: string;
     durationMs: number;
   }>;
+  /**
+   * Resolution evidence for structured rework findings linked to this task.
+   * All blocking findings must be resolved before completion is accepted.
+   * @optional
+   */
+  reworkResolution?: Array<{
+    findingId: string;
+    status: "resolved" | "deferred-with-override";
+    evidence: string;
+    decisionRef?: string;
+  }>;
   /**
    * Q5 failure-modes section content (what breaks when dependencies fail).
    * Populated → `pass`; omitted/empty → `omitted`.

package/src/resources/extensions/gsd/unit-registry.ts

@@ -290,6 +290,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",
@@ -303,6 +305,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/src/resources/extensions/gsd/uok/plan-v2.ts

@@ -6,7 +6,7 @@ import { join } from "node:path";
 
 import type { GSDState, Phase } from "../types.js";
 import { gsdRoot, resolveMilestoneFile, resolveSliceFile } from "../paths.js";
-import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "../gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getTasksBySliceIds } from "../gsd-db.js";
 import type { SliceRow } from "../db-task-slice-rows.js";
 import type { UokGraphNode } from "./contracts.js";
 
@@ -39,6 +39,19 @@ function graphOutputPath(basePath: string): string {
   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: string, output: Record<string, unknown>): boolean {
+  try {
+    const existing = JSON.parse(readFileSync(outPath, "utf-8")) as Record<string, unknown>;
+    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: string | null): boolean {
   if (!path || !existsSync(path)) return false;
   try {
@@ -120,9 +133,11 @@ export function compileUnitGraphFromState(basePath: string, state: GSDState): Pl
     };
   }
 
+  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: string | null = null;
@@ -174,7 +189,9 @@ export function compileUnitGraphFromState(basePath: string, state: GSDState): Pl
 
   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,

package/src/resources/extensions/gsd/worktree-state-projection.ts

@@ -179,6 +179,14 @@ function syncOtherMilestoneArtifacts(
   }
 }
 
+function syncFlatPhaseArtifacts(prGsd: string, wtGsd: string): void {
+  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
@@ -254,6 +262,10 @@ export function _projectRootToWorktreeImpl(
   // 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/src/resources/extensions/mac-tools/index.ts

@@ -17,6 +17,10 @@ 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
@@ -96,6 +100,45 @@ interface MacAgentResponse {
 	error?: string;
 }
 
+interface MacScreenshotPayload {
+	imageData: string;
+	width: number;
+	height: number;
+	format: string;
+	mimeType: string;
+}
+
+function macScreenshotQualityToPercent(quality: number | undefined): number {
+	if (quality === undefined || !Number.isFinite(quality)) return 80;
+	return Math.min(100, Math.max(1, Math.round(quality * 100)));
+}
+
+export async function prepareMacScreenshotPayload(
+	data: Record<string, any>,
+	quality: number | undefined,
+): Promise<MacScreenshotPayload> {
+	const format = data.format as string;
+	const mimeType = format === "png" ? "image/png" : "image/jpeg";
+	const rawBuffer = Buffer.from(data.imageData as string, "base64");
+	const constrainedBuffer = await constrainScreenshot(
+		null as any,
+		rawBuffer,
+		mimeType,
+		macScreenshotQualityToPercent(quality),
+	);
+	const dimensions = constrainedBuffer === rawBuffer
+		? null
+		: await getScreenshotBufferDimensions(constrainedBuffer);
+
+	return {
+		imageData: constrainedBuffer.toString("base64"),
+		width: dimensions?.width ?? (data.width as number),
+		height: dimensions?.height ?? (data.height as number),
+		format,
+		mimeType,
+	};
+}
+
 /**
  * Invoke the mac-agent CLI with a command and optional params.
  * Handles compilation caching, stdin/stdout JSON protocol, and error surfacing.
@@ -718,19 +761,19 @@ export default function (pi: ExtensionAPI) {
 				throw new Error("mac_screenshot: " + result.error);
 			}
 
-			const data = result.data!;
-			const imageData = data.imageData as string;
-			const format = data.format as string;
-			const width = data.width as number;
-			const height = data.height as number;
-			const mimeType = format === "png" ? "image/png" : "image/jpeg";
+			const screenshot = await prepareMacScreenshotPayload(result.data!, args.quality);
 
 			return {
 				content: [
-					{ type: "text" as const, text: `Screenshot: ${width}x${height} ${format}` },
-					{ type: "image" as const, data: imageData, mimeType },
+					{ type: "text" as const, text: `Screenshot: ${screenshot.width}x${screenshot.height} ${screenshot.format}` },
+					{ type: "image" as const, data: screenshot.imageData, mimeType: screenshot.mimeType },
 				],
-				details: { width, height, format, mimeType },
+				details: {
+					width: screenshot.width,
+					height: screenshot.height,
+					format: screenshot.format,
+					mimeType: screenshot.mimeType,
+				},
 			};
 		},
 	});

package/src/resources/extensions/mac-tools/tests/mac-screenshot-payload.test.cjs

@@ -0,0 +1,70 @@
+const { describe, it, afterEach } = require("node:test");
+const assert = require("node:assert/strict");
+const jiti = require("jiti")(__filename, { interopDefault: true, debug: false });
+
+const { prepareMacScreenshotPayload } = jiti("../index.ts");
+const { __setSharpForTesting } = jiti("../../browser-tools/screenshot-constraints.ts");
+
+async function createTestJpeg(width, height) {
+	const sharp = require("sharp");
+	return sharp({
+		create: {
+			width,
+			height,
+			channels: 3,
+			background: { r: 128, g: 128, b: 128 },
+		},
+	})
+		.jpeg({ quality: 80 })
+		.toBuffer();
+}
+
+describe("prepareMacScreenshotPayload", () => {
+	afterEach(() => {
+		__setSharpForTesting(undefined);
+	});
+
+	it("resizes oversized mac screenshots before returning base64 image data", async () => {
+		const sharp = require("sharp");
+		const input = await createTestJpeg(3000, 2000);
+
+		const result = await prepareMacScreenshotPayload(
+			{
+				imageData: input.toString("base64"),
+				format: "jpeg",
+				width: 3000,
+				height: 2000,
+			},
+			0.8,
+		);
+
+		const output = Buffer.from(result.imageData, "base64");
+		const meta = await sharp(output).metadata();
+		assert.equal(result.mimeType, "image/jpeg");
+		assert.equal(result.width, 1568);
+		assert.ok(result.height > 1000 && result.height < 1100);
+		assert.equal(meta.width, result.width);
+		assert.equal(meta.height, result.height);
+	});
+
+	it("falls back to raw screenshot data and original dimensions when sharp is unavailable", async () => {
+		__setSharpForTesting(null);
+		const input = await createTestJpeg(3000, 2000);
+		const inputBase64 = input.toString("base64");
+
+		const result = await prepareMacScreenshotPayload(
+			{
+				imageData: inputBase64,
+				format: "jpeg",
+				width: 3000,
+				height: 2000,
+			},
+			0.8,
+		);
+
+		assert.equal(result.imageData, inputBase64);
+		assert.equal(result.width, 3000);
+		assert.equal(result.height, 2000);
+		assert.equal(result.mimeType, "image/jpeg");
+	});
+});