@opengsd/gsd-pi 1.1.1-dev.9f86580 → 1.1.1-dev.b2556262

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

@@ -34,8 +34,8 @@ import { getGatesForTurn } from "../gate-registry.js";
 import { gsdProjectionRoot, clearPathCache, resolveMilestoneFile } from "../paths.js";
 import { resolveCanonicalMilestoneRoot } from "../worktree-manager.js";
 import { checkOwnership, sliceUnitKey } from "../unit-ownership.js";
-import { saveFile, clearParseCache, extractUatType } from "../files.js";
-import { hasBrowserRequiredText } from "../browser-evidence.js";
+import { saveFile, clearParseCache } from "../files.js";
+import { getDeclaredUatType, shouldEscalateArtifactUatToBrowser } from "../uat-policy.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb } from "../markdown-renderer.js";
 import { parseRoadmap } from "../parsers-legacy.js";
@@ -350,7 +350,7 @@ export async function handleCompleteSlice(
   // Otherwise the browser checks get silently deferred to a human and the slice
   // passes on static checks alone (M001/S03 regression). `browser-executable`,
   // `live-runtime`, and `mixed` all receive browser tools (see
-  // BROWSER_INCLUSIVE_UAT_TYPES); only the non-browser modes are rejected here.
+  // UAT_MODE_POLICIES); only the non-browser modes are rejected here.
   //
   // Reuse the canonical hasBrowserRequiredText detector (also used by dispatch
   // and milestone validation): it skips Not-Proven/Out-of-Scope disclaimer
@@ -362,9 +362,10 @@ export async function handleCompleteSlice(
   // genuinely defers verification to a human. Every other mode has a real
   // verification path: `runtime-executable` runs browser test commands like
   // `npx playwright test` via gsd_uat_exec, and live-runtime/mixed/
-  // browser-executable receive browser tools (BROWSER_INCLUSIVE_UAT_TYPES).
-  const declaredUatMode = extractUatType(params.uatContent || "") ?? "artifact-driven";
-  if (declaredUatMode === "artifact-driven" && hasBrowserRequiredText(params.uatContent || "")) {
+  // browser-executable receive browser tools (UAT_MODE_POLICIES).
+  const uatContent = params.uatContent || "";
+  const declaredUatMode = getDeclaredUatType(uatContent);
+  if (shouldEscalateArtifactUatToBrowser(uatContent)) {
     return {
       error: `UAT requires browser verification (opening a page in a browser, navigating to a page or localhost, screenshots) but declares "UAT mode: artifact-driven", which only runs static/file checks and would defer the browser work to a human. Use a mode that actually verifies the UI: "browser-executable" (interactive browser tools), "runtime-executable" (a browser test command such as playwright), or a browser-inclusive "mixed"/"live-runtime". Re-author the UAT Type section and complete the slice again.`,
     };

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

@@ -1,8 +1,9 @@
 import { existsSync, rmSync } from "node:fs";
-import { join, relative } from "node:path";
+import { join, relative, resolve } from "node:path";
 import { clearParseCache } from "../files.js";
 import { isClosedStatus, isDeferredStatus } from "../status-guards.js";
 import { isNonEmptyString, validateStringArray } from "../validation.js";
+import { getGateIdsForTurn } from "../gate-registry.js";
 import {
   transaction,
   getMilestone,
@@ -17,14 +18,14 @@ import {
   deleteTask,
   deleteArtifactByPath,
 } from "../gsd-db.js";
-import type { GateId } from "../types.js";
+import type { GateEvaluationConfig, GateId } from "../types.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
-import { validatePlanningPathScope } from "../planning-path-scope.js";
+import { validatePathOnlyPlanningFields, validatePlanningPathScope } from "../planning-path-scope.js";
 import { checkFilePathConsistency, checkTaskOrdering } from "../pre-execution-checks.js";
 import type { TaskRow } from "../db-task-slice-rows.js";
 import { buildTaskFileName, gsdProjectionRoot } from "../paths.js";
@@ -163,9 +164,27 @@ function validateParams(params: PlanSliceParams): PlanSliceParams {
   };
 }
 
-function loadRepositoryRegistry(basePath: string): RepositoryRegistry {
+function loadPlanningContext(basePath: string): {
+  repositoryRegistry: RepositoryRegistry;
+  gateEvaluation?: GateEvaluationConfig;
+} {
   const loaded = loadEffectiveGSDPreferences(basePath);
-  return createRepositoryRegistryFromPreferences(basePath, loaded?.preferences);
+  return {
+    repositoryRegistry: createRepositoryRegistryFromPreferences(basePath, loaded?.preferences),
+    gateEvaluation: loaded?.preferences?.gate_evaluation,
+  };
+}
+
+function resolveGateEvaluateSliceGates(config: GateEvaluationConfig | undefined): GateId[] {
+  const ownedGateIds = [...getGateIdsForTurn("gate-evaluate")];
+  if (!config?.slice_gates?.length) return ownedGateIds;
+  const owned = new Set<string>(ownedGateIds);
+  return config.slice_gates.filter((gateId): gateId is GateId => owned.has(gateId));
+}
+
+function resolveTaskGates(config: GateEvaluationConfig | undefined): GateId[] {
+  if (config?.task_gates === false) return [];
+  return [...getGateIdsForTurn("execute-task")];
 }
 
 function validateReferencedRepositories(
@@ -238,11 +257,21 @@ function toTaskRows(params: PlanSliceParams, defaultTargets: string[]): TaskRow[
   }));
 }
 
-function validateTaskPathsBeforePersist(params: PlanSliceParams, basePath: string, defaultTargets: string[]): string | null {
+function validateTaskPathsBeforePersist(
+  params: PlanSliceParams,
+  basePath: string,
+  defaultTargets: string[],
+  allowedRoots: string[],
+): string | null {
   const taskRows = toTaskRows(params, defaultTargets);
+  const baseRoot = resolve(basePath);
+  const additionalRoots = allowedRoots
+    .map((root) => resolve(root))
+    .filter((root) => root !== baseRoot);
+  const context = additionalRoots.length > 0 ? { additionalRoots } : undefined;
   const checks = [
-    ...checkFilePathConsistency(taskRows, basePath),
-    ...checkTaskOrdering(taskRows, basePath),
+    ...checkFilePathConsistency(taskRows, basePath, context),
+    ...checkTaskOrdering(taskRows, basePath, context),
   ];
   const blocking = checks.filter((check) => !check.passed && check.blocking);
 
@@ -265,8 +294,11 @@ export async function handlePlanSlice(
   }
 
   let repositoryRegistry: RepositoryRegistry;
+  let gateEvaluation: GateEvaluationConfig | undefined;
   try {
-    repositoryRegistry = loadRepositoryRegistry(basePath);
+    const context = loadPlanningContext(basePath);
+    repositoryRegistry = context.repositoryRegistry;
+    gateEvaluation = context.gateEvaluation;
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     return { error: `validation failed: ${message}` };
@@ -279,6 +311,16 @@ export async function handlePlanSlice(
 
   const allowedAbsoluteRoots = resolveAllowedRootsForPathScope(params, repositoryRegistry, defaultTargets);
 
+  const pathOnlyError = validatePathOnlyPlanningFields(
+    params.tasks.map((task, index) => ({
+      field: `tasks[${index}].expectedOutput`,
+      values: task.expectedOutput,
+    })),
+  );
+  if (pathOnlyError) {
+    return { error: `validation failed: ${pathOnlyError}` };
+  }
+
   const pathScopeError = validatePlanningPathScope(
     basePath,
     params.tasks.flatMap((task, index) => [
@@ -292,7 +334,7 @@ export async function handlePlanSlice(
     return { error: `validation failed: ${pathScopeError}` };
   }
 
-  const pathError = validateTaskPathsBeforePersist(params, basePath, defaultTargets);
+  const pathError = validateTaskPathsBeforePersist(params, basePath, defaultTargets, allowedAbsoluteRoots);
   if (pathError) {
     return { error: `pre-execution validation failed:\n${pathError}` };
   }
@@ -384,11 +426,11 @@ export async function handlePlanSlice(
 
       // Seed quality gate rows inside the transaction — all-or-nothing with
       // the plan data so a crash can't leave orphaned gates without tasks.
-      const sliceGates: GateId[] = ["Q3", "Q4"];
+      const sliceGates = resolveGateEvaluateSliceGates(gateEvaluation);
       for (const gid of sliceGates) {
         insertGateRow({ milestoneId: params.milestoneId, sliceId: params.sliceId, gateId: gid, scope: "slice" });
       }
-      const taskGates: GateId[] = ["Q5", "Q6", "Q7"];
+      const taskGates = resolveTaskGates(gateEvaluation);
       for (const task of params.tasks) {
         for (const gid of taskGates) {
           insertGateRow({ milestoneId: params.milestoneId, sliceId: params.sliceId, gateId: gid, scope: "task", taskId: task.taskId });

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

@@ -8,7 +8,7 @@ import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
-import { validatePlanningPathScope } from "../planning-path-scope.js";
+import { validatePathOnlyPlanningFields, validatePlanningPathScope } from "../planning-path-scope.js";
 
 export interface PlanTaskParams {
   milestoneId: string;
@@ -67,6 +67,13 @@ export async function handlePlanTask(
     return { error: `validation failed: ${(err as Error).message}` };
   }
 
+  const pathOnlyError = validatePathOnlyPlanningFields([
+    { field: "expectedOutput", values: params.expectedOutput },
+  ]);
+  if (pathOnlyError) {
+    return { error: `validation failed: ${pathOnlyError}` };
+  }
+
   const pathScopeError = validatePlanningPathScope(basePath, [
     { field: "files", values: params.files },
     { field: "inputs", values: params.inputs },