@opengsd/gsd-pi 1.3.0-dev.eed73bea → 1.4.0-dev.5fc22c6f

package/src/resources/extensions/gsd/tools/complete-task.ts

@@ -29,21 +29,18 @@ import {
   deleteVerificationEvidence,
   saveGateResult,
   getPendingGatesForTurn,
-  isDbAvailable,
 } from "../gsd-db.js";
-import { getWorkflowDatabasePath, openWorkflowDatabasePath } from "../db-workspace.js";
+import { getWorkflowDatabasePath, ensureWorkflowDbAtPath } from "../db-workspace.js";
 import { getGatesForTurn } from "../gate-registry.js";
 import { gsdProjectionRoot, clearPathCache, resolveMilestonePath, resolveSlicePath } from "../paths.js";
 import { resolveCanonicalMilestoneRoot } from "../worktree-manager.js";
 import { checkOwnership, taskUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
-import { renderPlanCheckboxes, renderRoadmapFromDb } from "../markdown-renderer.js";
+import { renderPlanCheckboxes } from "../markdown-renderer.js";
 import {
-  renderStateProjection,
+  renderMilestoneShellProjections,
   renderSummaryContent,
-  renderTopLevelQueueFromDb,
-  renderTopLevelRoadmapFromDb,
 } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
@@ -108,35 +105,6 @@ function taskSummaryPath(
   );
 }
 
-async function renderCompleteTaskProjections(basePath: string, milestoneId: string): Promise<void> {
-  try {
-    await renderRoadmapFromDb(basePath, milestoneId);
-  } catch (err) {
-    logWarning("projection", `renderRoadmapFromDb failed for ${milestoneId}: ${(err as Error).message}`);
-  }
-  try {
-    renderTopLevelRoadmapFromDb(basePath);
-  } catch (err) {
-    logWarning("projection", `renderTopLevelRoadmapFromDb failed: ${(err as Error).message}`);
-  }
-  try {
-    renderTopLevelQueueFromDb(basePath);
-  } catch (err) {
-    logWarning("projection", `renderTopLevelQueueFromDb failed: ${(err as Error).message}`);
-  }
-  try {
-    await renderStateProjection(basePath);
-  } catch (err) {
-    logWarning("projection", `renderStateProjection failed: ${(err as Error).message}`);
-  }
-}
-
-function ensureCompleteTaskDbOpen(dbPath: string | null): boolean {
-  if (!dbPath || dbPath === ":memory:") return isDbAvailable();
-  if (isDbAvailable() && getWorkflowDatabasePath() === dbPath) return true;
-  return openWorkflowDatabasePath(dbPath);
-}
-
 async function repairMissingTaskSummaryProjection(
   artifactBasePath: string,
   taskRow: TaskRow,
@@ -167,7 +135,7 @@ async function repairMissingTaskSummaryProjection(
   clearParseCache();
 
   try {
-    await renderCompleteTaskProjections(artifactBasePath, taskRow.milestone_id);
+    await renderMilestoneShellProjections(artifactBasePath, taskRow.milestone_id);
   } catch (projErr) {
     logWarning("tool", `complete-task repair projection warning: ${(projErr as Error).message}`);
   }
@@ -473,7 +441,7 @@ export async function handleCompleteTask(
 
     // Toggle or regenerate the plan projection from DB. Missing projection
     // files are rebuilt by the renderer instead of being skipped.
-    if (!ensureCompleteTaskDbOpen(rollbackDbPath)) {
+    if (!ensureWorkflowDbAtPath(rollbackDbPath)) {
       throw new Error(`database unavailable before plan projection render for ${params.milestoneId}/${params.sliceId}`);
     }
     const wrotePlan = await renderPlanCheckboxes(artifactBasePath, params.milestoneId, params.sliceId);
@@ -488,7 +456,7 @@ export async function handleCompleteTask(
     );
     let rollbackSucceeded = false;
     try {
-      ensureCompleteTaskDbOpen(rollbackDbPath);
+      ensureWorkflowDbAtPath(rollbackDbPath);
       deleteVerificationEvidence(params.milestoneId, params.sliceId, params.taskId);
       updateTaskStatus(params.milestoneId, params.sliceId, params.taskId, "pending");
       invalidateStateCache();
@@ -640,7 +608,7 @@ export async function handleCompleteTask(
   // Separate try/catch per step so a projection failure doesn't prevent
   // the event log entry (critical for worktree reconciliation).
   try {
-    await renderCompleteTaskProjections(artifactBasePath, params.milestoneId);
+    await renderMilestoneShellProjections(artifactBasePath, params.milestoneId);
   } catch (projErr) {
     logWarning("tool", `complete-task projection warning: ${(projErr as Error).message}`);
   }

package/src/resources/extensions/gsd/tools/plan-slice.ts

@@ -51,7 +51,7 @@ export interface PlanSliceParams {
   milestoneId: string;
   sliceId: string;
   goal: string;
-  tasks: PlanSliceTaskInput[];
+  tasks?: PlanSliceTaskInput[];
   /** @optional — omitted fields render as conservative defaults */
   successCriteria?: string;
   /** @optional — omitted fields render as conservative defaults */
@@ -86,10 +86,12 @@ function validateRepositoryTargetIds(
   return deduped;
 }
 
-function validateTasks(value: unknown): PlanSliceTaskInput[] {
-  if (!Array.isArray(value) || value.length === 0) {
-    throw new Error("tasks must be a non-empty array");
+function validateTasks(value: unknown): PlanSliceTaskInput[] | undefined {
+  if (value === undefined) return undefined;
+  if (!Array.isArray(value)) {
+    throw new Error("tasks must be an array");
   }
+  if (value.length === 0) return undefined;
 
   const seen = new Set<string>();
   return value.map((entry, index) => {
@@ -200,7 +202,7 @@ function validateReferencedRepositories(
   };
 
   for (const id of params.targetRepositories ?? defaultTargets) noteMissing(id);
-  for (const task of params.tasks) {
+  for (const task of params.tasks ?? []) {
     for (const id of task.targetRepositories ?? params.targetRepositories ?? defaultTargets) noteMissing(id);
   }
 
@@ -211,7 +213,7 @@ function validateReferencedRepositories(
 function resolveAllowedRootsForPathScope(params: PlanSliceParams, registry: RepositoryRegistry, defaultTargets: string[]): string[] {
   const requested = new Set<string>();
   for (const id of params.targetRepositories ?? defaultTargets) requested.add(id);
-  for (const task of params.tasks) {
+  for (const task of params.tasks ?? []) {
     for (const id of task.targetRepositories ?? params.targetRepositories ?? defaultTargets) requested.add(id);
   }
   if (requested.size === 0) return [registry.projectRoot];
@@ -222,7 +224,7 @@ function resolveAllowedRootsForPathScope(params: PlanSliceParams, registry: Repo
 }
 
 function toTaskRows(params: PlanSliceParams, defaultTargets: string[]): TaskRow[] {
-  return params.tasks.map((task, index) => ({
+  return (params.tasks ?? []).map((task, index) => ({
     milestone_id: params.milestoneId,
     slice_id: params.sliceId,
     id: task.taskId,
@@ -309,6 +311,8 @@ export async function handlePlanSlice(
     return { error: `validation failed: ${message}` };
   }
   const defaultTargets = defaultRepositoryTargets(repositoryRegistry);
+  const taskPayload = params.tasks ?? [];
+  const hasTaskPayload = taskPayload.length > 0;
   const repoValidationError = validateReferencedRepositories(params, repositoryRegistry, defaultTargets);
   if (repoValidationError) {
     return { error: `validation failed: ${repoValidationError}` };
@@ -317,7 +321,7 @@ export async function handlePlanSlice(
   const allowedAbsoluteRoots = resolveAllowedRootsForPathScope(params, repositoryRegistry, defaultTargets);
 
   const pathOnlyError = validatePathOnlyPlanningFields(
-    params.tasks.map((task, index) => ({
+    taskPayload.map((task, index) => ({
       field: `tasks[${index}].expectedOutput`,
       values: task.expectedOutput,
     })),
@@ -328,7 +332,7 @@ export async function handlePlanSlice(
 
   const pathScopeError = validatePlanningPathScope(
     basePath,
-    params.tasks.flatMap((task, index) => [
+    taskPayload.flatMap((task, index) => [
       { field: `tasks[${index}].files`, values: task.files },
       { field: `tasks[${index}].inputs`, values: task.inputs },
       { field: `tasks[${index}].expectedOutput`, values: task.expectedOutput },
@@ -372,16 +376,18 @@ export async function handlePlanSlice(
         return;
       }
 
-      const newTaskIds = new Set(params.tasks.map((task) => task.taskId));
+      const newTaskIds = new Set(taskPayload.map((task) => task.taskId));
       const existingTasks = getSliceTasks(params.milestoneId, params.sliceId);
-      omittedTaskIds = existingTasks
-        .filter((task) => !newTaskIds.has(task.id))
-        .map((task) => task.id);
-
-      for (const task of existingTasks) {
-        if (!newTaskIds.has(task.id) && isClosedStatus(task.status)) {
-          guardError = `cannot remove completed task ${task.id}`;
-          return;
+      if (hasTaskPayload) {
+        omittedTaskIds = existingTasks
+          .filter((task) => !newTaskIds.has(task.id))
+          .map((task) => task.id);
+
+        for (const task of existingTasks) {
+          if (!newTaskIds.has(task.id) && isClosedStatus(task.status)) {
+            guardError = `cannot remove completed task ${task.id}`;
+            return;
+          }
         }
       }
 
@@ -398,35 +404,37 @@ export async function handlePlanSlice(
         targetRepositories: params.targetRepositories ?? defaultTargets,
       });
 
-      for (const taskId of omittedTaskIds) {
-        deleteTask(params.milestoneId, params.sliceId, taskId);
-      }
+      if (hasTaskPayload) {
+        for (const taskId of omittedTaskIds) {
+          deleteTask(params.milestoneId, params.sliceId, taskId);
+        }
 
-      const existingTaskById = new Map(existingTasks.map((task) => [task.id, task]));
-      for (const task of params.tasks) {
-        const planning = {
-          title: task.title,
-          description: task.description,
-          estimate: task.estimate,
-          files: task.files,
-          verify: task.verify,
-          inputs: task.inputs,
-          expectedOutput: task.expectedOutput,
-          observabilityImpact: task.observabilityImpact ?? "",
-          fullPlanMd: task.fullPlanMd,
-          targetRepositories: task.targetRepositories ?? params.targetRepositories ?? defaultTargets,
-        };
-        const existingTask = existingTaskById.get(task.taskId);
-        if (!existingTask || !isClosedStatus(existingTask.status)) {
-          insertTask({
-            id: task.taskId,
-            sliceId: params.sliceId,
-            milestoneId: params.milestoneId,
+        const existingTaskById = new Map(existingTasks.map((task) => [task.id, task]));
+        for (const task of taskPayload) {
+          const planning = {
             title: task.title,
-            status: "pending",
-          });
+            description: task.description,
+            estimate: task.estimate,
+            files: task.files,
+            verify: task.verify,
+            inputs: task.inputs,
+            expectedOutput: task.expectedOutput,
+            observabilityImpact: task.observabilityImpact ?? "",
+            fullPlanMd: task.fullPlanMd,
+            targetRepositories: task.targetRepositories ?? params.targetRepositories ?? defaultTargets,
+          };
+          const existingTask = existingTaskById.get(task.taskId);
+          if (!existingTask || !isClosedStatus(existingTask.status)) {
+            insertTask({
+              id: task.taskId,
+              sliceId: params.sliceId,
+              milestoneId: params.milestoneId,
+              title: task.title,
+              status: "pending",
+            });
+          }
+          upsertTaskPlanning(params.milestoneId, params.sliceId, task.taskId, planning);
         }
-        upsertTaskPlanning(params.milestoneId, params.sliceId, task.taskId, planning);
       }
 
       // Seed quality gate rows inside the transaction — all-or-nothing with
@@ -436,7 +444,7 @@ export async function handlePlanSlice(
         insertGateRow({ milestoneId: params.milestoneId, sliceId: params.sliceId, gateId: gid, scope: "slice" });
       }
       const taskGates = resolveTaskGates(gateEvaluation);
-      for (const task of params.tasks) {
+      for (const task of taskPayload) {
         for (const gid of taskGates) {
           insertGateRow({ milestoneId: params.milestoneId, sliceId: params.sliceId, gateId: gid, scope: "task", taskId: task.taskId });
         }
@@ -460,8 +468,13 @@ export async function handlePlanSlice(
       deleteArtifactByPath(artifactPath);
     }
 
-    const renderResult = await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
-    setSliceSketchFlag(params.milestoneId, params.sliceId, false);
+    const sliceTasks = getSliceTasks(params.milestoneId, params.sliceId);
+    const renderResult = sliceTasks.length === 0
+      ? { planPath: "", taskPlanPaths: [] as string[] }
+      : await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
+    if (sliceTasks.length > 0) {
+      setSliceSketchFlag(params.milestoneId, params.sliceId, false);
+    }
     invalidateStateCache();
     clearParseCache();
 

package/src/resources/extensions/gsd/tools/plan-task.ts

@@ -1,15 +1,19 @@
 import { clearParseCache } from "../files.js";
 import { isClosedStatus } from "../status-guards.js";
 import { isNonEmptyString, validateStringArray } from "../validation.js";
-import { transaction, getSlice, getTask, insertTask, upsertTaskPlanning } from "../gsd-db.js";
+import { getGateIdsForTurn } from "../gate-registry.js";
+import { transaction, getSlice, getTask, insertTask, upsertTaskPlanning, insertGateRow, setSliceSketchFlag } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderTaskPlanFromDb, renderPlanFromDb } from "../markdown-renderer.js";
-import { resolveSliceFile, resolveTasksDir } from "../paths.js";
+import { resolveTasksDir } from "../paths.js";
 import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
+import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { validatePathOnlyPlanningFields, validatePlanningPathScope } from "../planning-path-scope.js";
+import { createRepositoryRegistryFromPreferences, defaultRepositoryTargets, type RepositoryRegistry } from "../repository-registry.js";
+import type { GateId } from "../types.js";
 
 export interface PlanTaskParams {
   milestoneId: string;
@@ -23,6 +27,8 @@ export interface PlanTaskParams {
   inputs: string[];
   expectedOutput: string[];
   observabilityImpact?: string;
+  /** Repository id(s) this task touches (parent workspace); omitted for single-repo projects. */
+  targetRepositories?: string[];
   fullPlanMd?: string;
   /** Optional caller-provided identity for audit trail */
   actorName?: string;
@@ -37,6 +43,63 @@ export interface PlanTaskResult {
   taskPlanPath: string;
 }
 
+function validateRepositoryTargetIds(field: string, value: unknown): string[] {
+  const ids = validateStringArray(value, field);
+  if (ids.length === 0) throw new Error(`${field} must include at least one repository id when provided`);
+  const deduped = Array.from(new Set(ids.map((id) => id.trim()).filter(Boolean)));
+  if (deduped.length === 0) throw new Error(`${field} must include at least one repository id when provided`);
+  return deduped;
+}
+
+function validateReferencedRepositories(
+  targetRepositories: string[] | undefined,
+  registry: RepositoryRegistry,
+): string | null {
+  if (!targetRepositories) return null;
+  const known = new Set(registry.repositories.map((repo) => repo.id));
+  const missing = targetRepositories.filter((id) => !known.has(id));
+  if (missing.length === 0) return null;
+  return `unknown targetRepositories: ${missing.join(", ")}. Declared repositories: ${Array.from(known).join(", ")}`;
+}
+
+function resolveAllowedRootsForPathScope(
+  targetRepositories: string[],
+  registry: RepositoryRegistry,
+): string[] {
+  if (targetRepositories.length === 0) return [registry.projectRoot];
+  const roots = targetRepositories
+    .map((id) => registry.byId.get(id)?.root)
+    .filter((root): root is string => typeof root === "string");
+  return roots.length > 0 ? roots : [registry.projectRoot];
+}
+
+function validatePathScopeForTargetRepositories(
+  params: PlanTaskParams,
+  basePath: string,
+  registry: RepositoryRegistry,
+  targetRepositories: string[],
+): string | null {
+  return validatePlanningPathScope(
+    basePath,
+    [
+      { field: "files", values: params.files },
+      { field: "inputs", values: params.inputs },
+      { field: "expectedOutput", values: params.expectedOutput },
+    ],
+    resolveAllowedRootsForPathScope(targetRepositories, registry),
+  );
+}
+
+function resolveEffectiveTargetRepositories(
+  taskTargetRepositories: string[] | undefined,
+  sliceTargetRepositories: string[] | undefined,
+  defaultTargets: string[],
+): string[] {
+  if (taskTargetRepositories) return taskTargetRepositories;
+  if (sliceTargetRepositories?.length) return sliceTargetRepositories;
+  return defaultTargets;
+}
+
 function validateParams(params: PlanTaskParams): PlanTaskParams {
   if (!isNonEmptyString(params?.milestoneId)) throw new Error("milestoneId is required");
   if (!isNonEmptyString(params?.sliceId)) throw new Error("sliceId is required");
@@ -54,9 +117,18 @@ function validateParams(params: PlanTaskParams): PlanTaskParams {
     files: validateStringArray(params.files, "files"),
     inputs: validateStringArray(params.inputs, "inputs"),
     expectedOutput: validateStringArray(params.expectedOutput, "expectedOutput"),
+    ...(params.targetRepositories !== undefined
+      ? { targetRepositories: validateRepositoryTargetIds("targetRepositories", params.targetRepositories) }
+      : {}),
   };
 }
 
+function resolveTaskGates(basePath: string): GateId[] {
+  const loaded = loadEffectiveGSDPreferences(basePath);
+  if (loaded?.preferences?.gate_evaluation?.task_gates === false) return [];
+  return [...getGateIdsForTurn("execute-task")];
+}
+
 export async function handlePlanTask(
   rawParams: PlanTaskParams,
   basePath: string,
@@ -75,15 +147,19 @@ export async function handlePlanTask(
     return { error: `validation failed: ${pathOnlyError}` };
   }
 
-  const pathScopeError = validatePlanningPathScope(basePath, [
-    { field: "files", values: params.files },
-    { field: "inputs", values: params.inputs },
-    { field: "expectedOutput", values: params.expectedOutput },
-  ]);
-  if (pathScopeError) {
-    return { error: `validation failed: ${pathScopeError}` };
+  let taskGates: GateId[];
+  let repositoryRegistry: RepositoryRegistry;
+  try {
+    taskGates = resolveTaskGates(basePath);
+    const loaded = loadEffectiveGSDPreferences(basePath);
+    repositoryRegistry = createRepositoryRegistryFromPreferences(basePath, loaded?.preferences);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { error: `validation failed: ${message}` };
   }
 
+  const defaultTargets = defaultRepositoryTargets(repositoryRegistry);
+
   // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
   // Guards must be inside the transaction so the state they check cannot
   // change between the read and the write (#2723).
@@ -107,6 +183,44 @@ export async function handlePlanTask(
         return;
       }
 
+      let effectiveTargetRepositories = resolveEffectiveTargetRepositories(
+        params.targetRepositories,
+        parentSlice.target_repositories,
+        defaultTargets,
+      );
+      const repoValidationError = validateReferencedRepositories(effectiveTargetRepositories, repositoryRegistry);
+      if (repoValidationError) {
+        guardError = `validation failed: ${repoValidationError}`;
+        return;
+      }
+
+      let pathScopeError = validatePathScopeForTargetRepositories(
+        params,
+        basePath,
+        repositoryRegistry,
+        effectiveTargetRepositories,
+      );
+      const storedTaskTargets = existingTask?.target_repositories?.length
+        ? existingTask.target_repositories
+        : undefined;
+      // Omitted targetRepositories inherit the current slice default first.
+      // Fall back to the stored task target only when that inherited scope
+      // rejects the replan paths, preserving explicit per-task parent-root work.
+      if (pathScopeError && params.targetRepositories === undefined && storedTaskTargets) {
+        const storedRepoValidationError = validateReferencedRepositories(storedTaskTargets, repositoryRegistry);
+        const storedPathScopeError = storedRepoValidationError
+          ? storedRepoValidationError
+          : validatePathScopeForTargetRepositories(params, basePath, repositoryRegistry, storedTaskTargets);
+        if (!storedPathScopeError) {
+          effectiveTargetRepositories = storedTaskTargets;
+          pathScopeError = null;
+        }
+      }
+      if (pathScopeError) {
+        guardError = `validation failed: ${pathScopeError}`;
+        return;
+      }
+
       if (!existingTask) {
         insertTask({
           id: params.taskId,
@@ -126,7 +240,11 @@ export async function handlePlanTask(
         expectedOutput: params.expectedOutput,
         observabilityImpact: params.observabilityImpact ?? "",
         fullPlanMd: params.fullPlanMd,
+        targetRepositories: effectiveTargetRepositories,
       });
+      for (const gid of taskGates) {
+        insertGateRow({ milestoneId: params.milestoneId, sliceId: params.sliceId, gateId: gid, scope: "task", taskId: params.taskId });
+      }
     });
   } catch (err) {
     return { error: `db write failed: ${(err as Error).message}` };
@@ -142,17 +260,22 @@ export async function handlePlanTask(
     // Flat-phase: tasks live as checkboxes in the slice plan's <tasks> block,
     // not as standalone TID-PLAN.md files. Re-render the slice plan so the
     // new/updated task appears in the plan file that gsd-core reads.
-    // Guard: resolveTasksDir is null in flat-phase (no tasks/ subdir exists);
-    //        only sync if a slice plan already exists (guards pre-plan-slice calls).
+    // Guard: resolveTasksDir is null in flat-phase (no tasks/ subdir exists).
+    let slicePlanSynced = false;
     try {
       const tDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);
-      if (!tDir && resolveSliceFile(basePath, params.milestoneId, params.sliceId, "PLAN")) {
+      if (!tDir) {
         await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
+        slicePlanSynced = true;
       }
     } catch (syncErr) {
       logWarning("tool", `plan-task: slice-plan sync failed: ${(syncErr as Error).message}`);
     }
 
+    if (slicePlanSynced) {
+      setSliceSketchFlag(params.milestoneId, params.sliceId, false);
+    }
+
     invalidateStateCache();
     clearParseCache();
 

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

@@ -53,11 +53,13 @@ import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { parseProject } from "../schemas/parsers.js";
 import { autoSession, getAutoRuntimeSnapshot, isAutoActive } from "../auto-runtime-state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
+import { readUnitHarnessAbort, type UnitHarnessAbortRecord } from "../unit-runtime.js";
 import {
   prepareUatRun,
   saveUatAttemptArtifact,
   type UatResultSaveParams,
 } from "../uat-run.js";
+import { appendNotification } from "../notification-store.js";
 import { registerAutoWorker, markWorkerStopping, getAutoWorker } from "../db/auto-workers.js";
 import {
   claimMilestoneLease,
@@ -116,6 +118,48 @@ function blockIfWrongAutoUnit(requiredUnitType: string, operation: string): Tool
   };
 }
 
+function blockIfHarnessAbortedUnit(operation: string, basePath: string): ToolExecutionResult | null {
+  const snapshot = getAutoRuntimeSnapshot();
+  if (!snapshot.active || !snapshot.currentUnit) return null;
+
+  const abort = readUnitHarnessAbort(
+    snapshot.basePath || basePath,
+    snapshot.currentUnit.type,
+    snapshot.currentUnit.id,
+    snapshot.currentUnit.startedAt,
+  );
+  if (!abort) return null;
+
+  return harnessAbortResult(operation, snapshot.currentUnit.type, snapshot.currentUnit.id, abort);
+}
+
+function harnessAbortResult(
+  operation: string,
+  unitType: string,
+  unitId: string,
+  abort: UnitHarnessAbortRecord,
+): ToolExecutionResult {
+  const toolText = abort.toolName ? ` while calling ${abort.toolName}` : "";
+  const message =
+    `Retryable harness abort: ${unitType} ${unitId} was truncated by ${abort.kind}${toolText}. ` +
+    "This gate result was not saved; leave the gate pending so auto-mode can rerun it.";
+  return {
+    content: [{ type: "text", text: message }],
+    details: {
+      operation,
+      error: "harness_aborted_needs_retry",
+      retryable: true,
+      unitType,
+      unitId,
+      harnessAbortKind: abort.kind,
+      harnessAbortReason: abort.reason,
+      harnessAbortToolName: abort.toolName,
+      harnessAbortCount: abort.count,
+    },
+    isError: true,
+  };
+}
+
 function milestoneLeaseConflictResult(
   milestoneId: string,
   byWorker: string,
@@ -1135,6 +1179,9 @@ export async function executeSaveGateResult(
   params: SaveGateResultParams,
   basePath: string = process.cwd(),
 ): Promise<ToolExecutionResult> {
+  const harnessAbort = blockIfHarnessAbortedUnit("save_gate_result", basePath);
+  if (harnessAbort) return harnessAbort;
+
   const dbAvailable = await ensureDbOpen(basePath);
   if (!dbAvailable) {
     return {
@@ -1206,6 +1253,9 @@ export async function executeUatResultSave(
   const unitGuard = blockIfWrongAutoUnit("run-uat", "save_uat_result");
   if (unitGuard) return unitGuard;
 
+  const harnessAbort = blockIfHarnessAbortedUnit("save_uat_result", basePath);
+  if (harnessAbort) return harnessAbort;
+
   const dbAvailable = await ensureDbOpen(basePath);
   if (!dbAvailable) return errorResult("save_uat_result", "GSD database is not available.", "db_unavailable");
 
@@ -1268,6 +1318,14 @@ export async function executeUatResultSave(
       evaluatedAt: run.evaluatedAt,
     });
     invalidateStateCache();
+    if (run.hasHuman) {
+      appendNotification(
+        `UAT for ${run.params.milestoneId}/${run.params.sliceId} has NEEDS-HUMAN checks awaiting human validation`,
+        "warning",
+        "notify",
+        { kind: "uat-needs-human", scope: `${run.params.milestoneId}/${run.params.sliceId}` },
+      );
+    }
     const savedText = `UAT result saved for ${run.params.milestoneId}/${run.params.sliceId}: ${run.params.verdict}`;
     return {
       content: [{