gsd-pi 2.74.0-dev.2b524c3 → 2.74.0-dev.658744a

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

@@ -83,6 +83,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set<string>([
   "post_unit_hooks",
   "pre_dispatch_hooks",
   "dynamic_routing",
+  "uok",
   "token_profile",
   "phases",
   "auto_visualize",
@@ -114,6 +115,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set<string>([
   "discuss_web_research",
   "discuss_depth",
   "flat_rate_providers",
+  "language",
 ]);
 
 /** Canonical list of all dispatch unit types. */
@@ -208,6 +210,35 @@ export interface CmuxPreferences {
   browser?: boolean;
 }
 
+export type UokTurnActionMode = "commit" | "snapshot" | "status-only";
+
+export interface UokPreferences {
+  enabled?: boolean;
+  legacy_fallback?: {
+    enabled?: boolean;
+  };
+  gates?: {
+    enabled?: boolean;
+  };
+  model_policy?: {
+    enabled?: boolean;
+  };
+  execution_graph?: {
+    enabled?: boolean;
+  };
+  gitops?: {
+    enabled?: boolean;
+    turn_action?: UokTurnActionMode;
+    turn_push?: boolean;
+  };
+  audit_unified?: {
+    enabled?: boolean;
+  };
+  plan_v2?: {
+    enabled?: boolean;
+  };
+}
+
 /**
  * Opt-in experimental features. All features in this block are disabled by
  * default and must be explicitly enabled. They may change or be removed without
@@ -256,6 +287,8 @@ export interface GSDPreferences {
   post_unit_hooks?: PostUnitHookConfig[];
   pre_dispatch_hooks?: PreDispatchHookConfig[];
   dynamic_routing?: DynamicRoutingConfig;
+  /** Unified Orchestration Kernel controls (all flags default off). */
+  uok?: UokPreferences;
   /** Per-model capability overrides. Deep-merged with built-in profiles for capability-aware routing (ADR-004). */
   modelOverrides?: Record<string, { capabilities?: Partial<ModelCapabilities> }>;
   context_management?: ContextManagementConfig;
@@ -371,6 +404,11 @@ export interface GSDPreferences {
    * same regardless of model.  Case-insensitive.
    */
   flat_rate_providers?: string[];
+  /**
+   * Language preference for GSD responses. Accepts any language name or code
+   * (e.g. "Chinese", "zh", "German", "de", "日本語"). Persists across /clear.
+   */
+  language?: string;
 }
 
 export interface LoadedGSDPreferences {

package/src/resources/extensions/gsd/preferences-validation.ts

@@ -22,7 +22,12 @@ import {
   type GSDSkillRule,
 } from "./preferences-types.js";
 
-const VALID_TOKEN_PROFILES = new Set<TokenProfile>(["budget", "balanced", "quality"]);
+const VALID_TOKEN_PROFILES = new Set<TokenProfile>(["budget", "balanced", "quality", "burn-max"]);
+const VALID_UOK_TURN_ACTIONS = new Set<"commit" | "snapshot" | "status-only">([
+  "commit",
+  "snapshot",
+  "status-only",
+]);
 
 export function validatePreferences(preferences: GSDPreferences): {
   preferences: GSDPreferences;
@@ -161,12 +166,112 @@ export function validatePreferences(preferences: GSDPreferences): {
     }
   }
 
+  // ─── UOK Flags ──────────────────────────────────────────────────────
+  if (preferences.uok !== undefined) {
+    if (typeof preferences.uok === "object" && preferences.uok !== null) {
+      const raw = preferences.uok as Record<string, unknown>;
+      const valid: NonNullable<GSDPreferences["uok"]> = {};
+
+      if (raw.enabled !== undefined) {
+        if (typeof raw.enabled === "boolean") valid.enabled = raw.enabled;
+        else errors.push("uok.enabled must be a boolean");
+      }
+
+      const parseEnabledBlock = (
+        key: "legacy_fallback" | "gates" | "model_policy" | "execution_graph" | "audit_unified" | "plan_v2",
+      ): void => {
+        const value = raw[key];
+        if (value === undefined) return;
+        if (typeof value !== "object" || value === null) {
+          errors.push(`uok.${key} must be an object`);
+          return;
+        }
+        const block = value as Record<string, unknown>;
+        const parsed: { enabled?: boolean } = {};
+        if (block.enabled !== undefined) {
+          if (typeof block.enabled === "boolean") parsed.enabled = block.enabled;
+          else errors.push(`uok.${key}.enabled must be a boolean`);
+        }
+        const unknown = Object.keys(block).filter((k) => k !== "enabled");
+        for (const unk of unknown) {
+          warnings.push(`unknown uok.${key} key "${unk}" — ignored`);
+        }
+        if (Object.keys(parsed).length > 0) {
+          valid[key] = parsed;
+        }
+      };
+
+      parseEnabledBlock("legacy_fallback");
+      parseEnabledBlock("gates");
+      parseEnabledBlock("model_policy");
+      parseEnabledBlock("execution_graph");
+      parseEnabledBlock("audit_unified");
+      parseEnabledBlock("plan_v2");
+
+      if (raw.gitops !== undefined) {
+        if (typeof raw.gitops !== "object" || raw.gitops === null) {
+          errors.push("uok.gitops must be an object");
+        } else {
+          const gitops = raw.gitops as Record<string, unknown>;
+          const parsed: NonNullable<NonNullable<GSDPreferences["uok"]>["gitops"]> = {};
+          if (gitops.enabled !== undefined) {
+            if (typeof gitops.enabled === "boolean") parsed.enabled = gitops.enabled;
+            else errors.push("uok.gitops.enabled must be a boolean");
+          }
+          if (gitops.turn_action !== undefined) {
+            if (
+              typeof gitops.turn_action === "string" &&
+              VALID_UOK_TURN_ACTIONS.has(gitops.turn_action as "commit" | "snapshot" | "status-only")
+            ) {
+              parsed.turn_action = gitops.turn_action as "commit" | "snapshot" | "status-only";
+            } else {
+              errors.push("uok.gitops.turn_action must be one of: commit, snapshot, status-only");
+            }
+          }
+          if (gitops.turn_push !== undefined) {
+            if (typeof gitops.turn_push === "boolean") parsed.turn_push = gitops.turn_push;
+            else errors.push("uok.gitops.turn_push must be a boolean");
+          }
+          const unknown = Object.keys(gitops).filter((k) => !["enabled", "turn_action", "turn_push"].includes(k));
+          for (const unk of unknown) {
+            warnings.push(`unknown uok.gitops key "${unk}" — ignored`);
+          }
+          if (Object.keys(parsed).length > 0) {
+            valid.gitops = parsed;
+          }
+        }
+      }
+
+      const knownUokKeys = new Set([
+        "enabled",
+        "legacy_fallback",
+        "gates",
+        "model_policy",
+        "execution_graph",
+        "gitops",
+        "audit_unified",
+        "plan_v2",
+      ]);
+      for (const key of Object.keys(raw)) {
+        if (!knownUokKeys.has(key)) {
+          warnings.push(`unknown uok key "${key}" — ignored`);
+        }
+      }
+
+      if (Object.keys(valid).length > 0) {
+        validated.uok = valid;
+      }
+    } else {
+      errors.push("uok must be an object");
+    }
+  }
+
   // ─── Token Profile ─────────────────────────────────────────────────
   if (preferences.token_profile !== undefined) {
     if (typeof preferences.token_profile === "string" && VALID_TOKEN_PROFILES.has(preferences.token_profile as TokenProfile)) {
       validated.token_profile = preferences.token_profile as TokenProfile;
     } else {
-      errors.push(`token_profile must be one of: budget, balanced, quality`);
+      errors.push(`token_profile must be one of: budget, balanced, quality, burn-max`);
     }
   }
 
@@ -1002,5 +1107,15 @@ export function validatePreferences(preferences: GSDPreferences): {
     }
   }
 
+  // ─── Language ────────────────────────────────────────────────────────
+  if (preferences.language !== undefined) {
+    const trimmed = typeof preferences.language === "string" ? preferences.language.trim() : undefined;
+    if (trimmed && trimmed.length <= 50 && !/[\r\n]/.test(trimmed)) {
+      validated.language = trimmed;
+    } else {
+      errors.push(`language must be a non-empty string up to 50 characters with no newlines (e.g. "Chinese", "de", "日本語")`);
+    }
+  }
+
   return { preferences: validated, errors, warnings };
 }

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

@@ -50,6 +50,8 @@ export type {
   AutoSupervisorConfig,
   RemoteQuestionsConfig,
   CmuxPreferences,
+  UokTurnActionMode,
+  UokPreferences,
   CodebaseMapPreferences,
   GSDPreferences,
   LoadedGSDPreferences,
@@ -378,6 +380,32 @@ function mergePreferences(base: GSDPreferences, override: GSDPreferences): GSDPr
     dynamic_routing: (base.dynamic_routing || override.dynamic_routing)
       ? { ...(base.dynamic_routing ?? {}), ...(override.dynamic_routing ?? {}) } as DynamicRoutingConfig
       : undefined,
+    uok: (base.uok || override.uok)
+      ? {
+          enabled: override.uok?.enabled ?? base.uok?.enabled,
+          legacy_fallback: (base.uok?.legacy_fallback || override.uok?.legacy_fallback)
+            ? { ...(base.uok?.legacy_fallback ?? {}), ...(override.uok?.legacy_fallback ?? {}) }
+            : undefined,
+          gates: (base.uok?.gates || override.uok?.gates)
+            ? { ...(base.uok?.gates ?? {}), ...(override.uok?.gates ?? {}) }
+            : undefined,
+          model_policy: (base.uok?.model_policy || override.uok?.model_policy)
+            ? { ...(base.uok?.model_policy ?? {}), ...(override.uok?.model_policy ?? {}) }
+            : undefined,
+          execution_graph: (base.uok?.execution_graph || override.uok?.execution_graph)
+            ? { ...(base.uok?.execution_graph ?? {}), ...(override.uok?.execution_graph ?? {}) }
+            : undefined,
+          gitops: (base.uok?.gitops || override.uok?.gitops)
+            ? { ...(base.uok?.gitops ?? {}), ...(override.uok?.gitops ?? {}) }
+            : undefined,
+          audit_unified: (base.uok?.audit_unified || override.uok?.audit_unified)
+            ? { ...(base.uok?.audit_unified ?? {}), ...(override.uok?.audit_unified ?? {}) }
+            : undefined,
+          plan_v2: (base.uok?.plan_v2 || override.uok?.plan_v2)
+            ? { ...(base.uok?.plan_v2 ?? {}), ...(override.uok?.plan_v2 ?? {}) }
+            : undefined,
+        }
+      : undefined,
     token_profile: override.token_profile ?? base.token_profile,
     phases: (base.phases || override.phases)
       ? { ...(base.phases ?? {}), ...(override.phases ?? {}) }
@@ -419,6 +447,7 @@ function mergePreferences(base: GSDPreferences, override: GSDPreferences): GSDPr
     slice_parallel: (base.slice_parallel || override.slice_parallel)
       ? { ...(base.slice_parallel ?? {}), ...(override.slice_parallel ?? {}) }
       : undefined,
+    language: override.language ?? base.language,
   };
 }
 
@@ -534,6 +563,11 @@ export function renderPreferencesForSystemPrompt(preferences: GSDPreferences, re
     }
   }
 
+  if (preferences.language) {
+    const safeLang = preferences.language.replace(/[\r\n]/g, " ").slice(0, 50);
+    lines.push(`- Language: Always respond in ${safeLang}.`);
+  }
+
   return lines.join("\n");
 }
 

package/src/resources/extensions/gsd/prompts/add-tests.md

@@ -0,0 +1,35 @@
+You are generating tests for recently completed GSD work.
+
+## Slice: {{sliceId}} — {{sliceTitle}}
+
+### Summary
+
+{{sliceSummary}}
+
+### Existing Test Patterns
+
+{{existingTestPatterns}}
+
+## Working Directory
+
+`{{workingDirectory}}`
+
+## Instructions
+
+1. Read the slice summary above to understand what was built
+2. Identify the source files that were created or modified for this slice
+3. Read the implementation code to understand behavior, edge cases, and error paths
+4. Write comprehensive tests following the project's existing test patterns and framework
+5. Run the tests to verify they pass
+6. Fix any failures
+
+### Rules
+
+- Follow the project's existing test patterns (framework, assertions, file structure)
+- Test behavior, not implementation details
+- Cover: happy path, edge cases, error conditions, boundary values
+- Do NOT modify implementation files — only create or update test files
+- Name test files consistently with the project's conventions
+- Keep tests focused and readable
+
+{{skillActivation}}

package/src/resources/extensions/gsd/safety/evidence-collector.ts

@@ -68,11 +68,11 @@ export function getFilePaths(): string[] {
  * Record a tool call at dispatch time (before execution).
  * Exit codes and output are filled in by recordToolResult after execution.
  */
-export function recordToolCall(toolName: string, input: Record<string, unknown>): void {
+export function recordToolCall(toolCallId: string, toolName: string, input: Record<string, unknown>): void {
   if (toolName === "bash" || toolName === "Bash") {
     unitEvidence.push({
       kind: "bash",
-      toolCallId: "",
+      toolCallId,
       command: String(input.command ?? ""),
       exitCode: -1,
       outputSnippet: "",
@@ -81,14 +81,14 @@ export function recordToolCall(toolName: string, input: Record<string, unknown>)
   } else if (toolName === "write" || toolName === "Write") {
     unitEvidence.push({
       kind: "write",
-      toolCallId: "",
+      toolCallId,
       path: String(input.file_path ?? input.path ?? ""),
       timestamp: Date.now(),
     });
   } else if (toolName === "edit" || toolName === "Edit") {
     unitEvidence.push({
       kind: "edit",
-      toolCallId: "",
+      toolCallId,
       path: String(input.file_path ?? input.path ?? ""),
       timestamp: Date.now(),
     });
@@ -96,8 +96,9 @@ export function recordToolCall(toolName: string, input: Record<string, unknown>)
 }
 
 /**
- * Record a tool execution result. Matches the most recent unresolved entry
- * of the same kind and fills in the toolCallId, exit code, and output.
+ * Record a tool execution result. Matches the entry by toolCallId (assigned
+ * at dispatch time) and fills in exit code + output. Prior versions matched
+ * by `kind + empty-string` which corrupted parallel tool calls.
  */
 export function recordToolResult(
   toolCallId: string,
@@ -105,36 +106,19 @@ export function recordToolResult(
   result: unknown,
   isError: boolean,
 ): void {
-  const normalizedName = toolName.toLowerCase();
-
-  if (normalizedName === "bash") {
-    const entry = findLastUnresolved("bash") as BashEvidence | undefined;
-    if (entry) {
-      entry.toolCallId = toolCallId;
-      const text = extractResultText(result);
-      entry.outputSnippet = text.slice(0, 500);
-      const exitMatch = text.match(/Command exited with code (\d+)/);
-      entry.exitCode = exitMatch ? Number(exitMatch[1]) : (isError ? 1 : 0);
-    }
-  } else if (normalizedName === "write" || normalizedName === "edit") {
-    const entry = findLastUnresolved(normalizedName as "write" | "edit");
-    if (entry) {
-      entry.toolCallId = toolCallId;
-    }
+  const entry = unitEvidence.find(e => e.toolCallId === toolCallId);
+  if (!entry) return;
+
+  if (entry.kind === "bash") {
+    const text = extractResultText(result);
+    entry.outputSnippet = text.slice(0, 500);
+    const exitMatch = text.match(/Command exited with code (\d+)/);
+    entry.exitCode = exitMatch ? Number(exitMatch[1]) : (isError ? 1 : 0);
   }
 }
 
 // ─── Internals ──────────────────────────────────────────────────────────────
 
-function findLastUnresolved(kind: string): EvidenceEntry | undefined {
-  for (let i = unitEvidence.length - 1; i >= 0; i--) {
-    if (unitEvidence[i].kind === kind && unitEvidence[i].toolCallId === "") {
-      return unitEvidence[i];
-    }
-  }
-  return undefined;
-}
-
 function extractResultText(result: unknown): string {
   if (typeof result === "string") return result;
   if (result && typeof result === "object") {

package/src/resources/extensions/gsd/session-lock.ts

@@ -52,6 +52,18 @@ export interface SessionLockStatus {
   recovered?: boolean;
 }
 
+interface ProperLockfileApi {
+  lockSync(
+    path: string,
+    options?: {
+      realpath?: boolean;
+      stale?: number;
+      update?: number;
+      onCompromised?: () => void;
+    },
+  ): () => void;
+}
+
 // ─── Module State ───────────────────────────────────────────────────────────
 
 /** Release function from proper-lockfile — calling it releases the OS lock. */
@@ -277,9 +289,9 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
     unitStartedAt: new Date().toISOString(),
   };
 
-  let lockfile: typeof import("proper-lockfile");
+  let lockfile: ProperLockfileApi;
   try {
-    lockfile = _require("proper-lockfile") as typeof import("proper-lockfile");
+    lockfile = _require("proper-lockfile") as ProperLockfileApi;
   } catch {
     // proper-lockfile not available — fall back to PID-based check
     return acquireFallbackLock(basePath, lp, lockData);

package/src/resources/extensions/gsd/slice-parallel-orchestrator.ts

@@ -32,6 +32,7 @@ import {
 } from "./session-status-io.js";
 import { hasFileConflict } from "./slice-parallel-conflict.js";
 import { getErrorMessage } from "./error-utils.js";
+import { selectConflictFreeBatch } from "./uok/execution-graph.js";
 
 // ─── Types ─────────────────────────────────────────────────────────────────
 
@@ -61,6 +62,7 @@ export interface SliceOrchestratorState {
 export interface StartSliceParallelOpts {
   maxWorkers?: number;
   budgetCeiling?: number;
+  useExecutionGraph?: boolean;
 }
 
 // ─── Module State ──────────────────────────────────────────────────────────
@@ -118,7 +120,12 @@ export async function startSliceParallel(
   const errors: Array<{ sid: string; error: string }> = [];
 
   // Filter out conflicting slices (conservative: check all pairs)
-  const safeSlices = filterConflictingSlices(basePath, milestoneId, eligibleSlices);
+  const safeSlices = filterConflictingSlices(
+    basePath,
+    milestoneId,
+    eligibleSlices,
+    opts.useExecutionGraph === true,
+  );
 
   // Limit to maxWorkers
   const toSpawn = safeSlices.slice(0, maxWorkers);
@@ -245,7 +252,19 @@ function filterConflictingSlices(
   basePath: string,
   milestoneId: string,
   slices: Array<{ id: string }>,
+  useExecutionGraph: boolean,
 ): Array<{ id: string }> {
+  if (useExecutionGraph) {
+    const selectedIds = selectConflictFreeBatch({
+      orderedIds: slices.map((slice) => slice.id),
+      maxParallel: slices.length,
+      hasConflict: (candidate, existing) =>
+        hasFileConflict(basePath, milestoneId, candidate, existing),
+    });
+    const selected = new Set(selectedIds);
+    return slices.filter((slice) => selected.has(slice.id));
+  }
+
   const safe: Array<{ id: string }> = [];
 
   for (const candidate of slices) {

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

@@ -345,8 +345,15 @@ function reconcileDiskToDb(basePath: string): MilestoneRow[] {
     const dbSliceIds = new Set(dbSlices.map(s => s.id));
 
     let roadmapContent: string;
-    try { roadmapContent = readFileSync(roadmapPath, "utf-8"); }
-    catch { continue; }
+    try {
+      roadmapContent = readFileSync(roadmapPath, "utf-8");
+    } catch (err) {
+      logWarning("state", "reconcileDiskToDb: roadmap read failed, skipping milestone", {
+        mid,
+        error: (err as Error).message,
+      });
+      continue;
+    }
 
     const parsed = parseRoadmap(roadmapContent);
     for (const s of parsed.slices) {

package/src/resources/extensions/gsd/templates/PREFERENCES.md

@@ -39,6 +39,24 @@ dynamic_routing:
   budget_pressure:
   cross_provider:
   hooks:
+uok:
+  enabled: true
+  legacy_fallback:
+    enabled: false
+  gates:
+    enabled: false
+  model_policy:
+    enabled: false
+  execution_graph:
+    enabled: false
+  gitops:
+    enabled: false
+    turn_action: status-only
+    turn_push: false
+  audit_unified:
+    enabled: false
+  plan_v2:
+    enabled: false
 auto_visualize:
 auto_report:
 parallel:
@@ -71,6 +89,7 @@ remote_questions:
 uat_dispatch:
 post_unit_hooks: []
 pre_dispatch_hooks: []
+# language:
 # experimental:
 #   rtk: false
 ---