gsd-pi 2.74.0-dev.2b524c3 → 2.74.0-dev.703eabc

package/src/resources/extensions/gsd/auto-dispatch.ts

@@ -53,6 +53,8 @@ import {
   checkNeedsRunUat,
 } from "./auto-prompts.js";
 import { resolveModelWithFallbacksForUnit } from "./preferences-models.js";
+import { resolveUokFlags } from "./uok/flags.js";
+import { selectReactiveDispatchBatch } from "./uok/execution-graph.js";
 
 // ─── Types ────────────────────────────────────────────────────────────────
 
@@ -584,12 +586,20 @@ export const DISPATCH_RULES: DispatchRule[] = [
         // Only activate reactive dispatch when >1 task is ready
         if (readyIds.length <= 1) return null;
 
-        const selected = chooseNonConflictingSubset(
-          readyIds,
-          graph,
-          maxParallel,
-          new Set(),
-        );
+        const uokFlags = resolveUokFlags(prefs);
+        const selected = uokFlags.executionGraph
+          ? selectReactiveDispatchBatch({
+              graph,
+              readyIds,
+              maxParallel,
+              inFlightOutputs: new Set(),
+            }).selected
+          : chooseNonConflictingSubset(
+              readyIds,
+              graph,
+              maxParallel,
+              new Set(),
+            );
         if (selected.length <= 1) return null;
 
         // Log graph metrics for observability

package/src/resources/extensions/gsd/auto-model-selection.ts

@@ -10,12 +10,14 @@ import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
 import type { GSDPreferences } from "./preferences.js";
 import { resolveModelWithFallbacksForUnit, resolveDynamicRoutingConfig } from "./preferences.js";
 import type { ComplexityTier } from "./complexity-classifier.js";
-import { classifyUnitComplexity, tierLabel } from "./complexity-classifier.js";
+import { classifyUnitComplexity, extractTaskMetadata, tierLabel } from "./complexity-classifier.js";
 import { resolveModelForComplexity, escalateTier, getEligibleModels, loadCapabilityOverrides, adjustToolSet, filterToolsForProvider } from "./model-router.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { unitPhaseLabel } from "./auto-dashboard.js";
 import { getSessionModelOverride } from "./session-model-override.js";
 import { logWarning } from "./workflow-logger.js";
+import { resolveUokFlags } from "./uok/flags.js";
+import { applyModelPolicyFilter } from "./uok/model-policy.js";
 
 export interface ModelSelectionResult {
   /** Routing metadata for metrics recording */
@@ -75,6 +77,7 @@ export async function selectAndApplyModel(
   /** Explicit /gsd model pin captured at bootstrap for long-running auto loops. */
   sessionModelOverride?: { provider: string; id: string } | null,
 ): Promise<ModelSelectionResult> {
+  const uokFlags = resolveUokFlags(prefs);
   const effectiveSessionModelOverride = sessionModelOverride === undefined
     ? getSessionModelOverride(ctx.sessionManager.getSessionId())
     : (sessionModelOverride ?? undefined);
@@ -97,6 +100,9 @@ export async function selectAndApplyModel(
 
   if (modelConfig) {
     const availableModels = ctx.modelRegistry.getAvailable();
+    const modelPolicyTraceId = `model:${ctx.sessionManager.getSessionId()}:${Date.now()}`;
+    const modelPolicyTurnId = `${unitType}:${unitId}`;
+    let policyAllowedModelKeys: Set<string> | null = null;
 
     // ─── Dynamic Model Routing ─────────────────────────────────────────
     // Dynamic routing (complexity-based downgrading) only applies in auto-mode.
@@ -106,8 +112,40 @@ export async function selectAndApplyModel(
     if (!isAutoMode) {
       routingConfig.enabled = false;
     }
+    // burn-max defaults to quality-first dispatch (no downgrade routing).
+    if (prefs?.token_profile === "burn-max") {
+      routingConfig.enabled = false;
+    }
     let effectiveModelConfig = modelConfig;
     let routingTierLabel = "";
+    let routingEligibleModels = availableModels;
+
+    const taskMetadataForPolicy = unitType === "execute-task"
+      ? extractTaskMetadata(unitId, basePath)
+      : undefined;
+
+    if (uokFlags.modelPolicy) {
+      const policy = applyModelPolicyFilter(
+        availableModels,
+        {
+          basePath,
+          traceId: modelPolicyTraceId,
+          turnId: modelPolicyTurnId,
+          unitType,
+          taskMetadata: taskMetadataForPolicy,
+          currentProvider: ctx.model?.provider,
+          allowCrossProvider: routingConfig.cross_provider !== false,
+          requiredTools: pi.getActiveTools(),
+        },
+      );
+      routingEligibleModels = policy.eligible;
+      policyAllowedModelKeys = new Set(
+        policy.eligible.map((m) => `${m.provider.toLowerCase()}/${m.id.toLowerCase()}`),
+      );
+      if (routingEligibleModels.length === 0) {
+        throw new Error(`Model policy denied all candidate models for ${unitType}/${unitId}`);
+      }
+    }
 
     // Disable routing for flat-rate providers like GitHub Copilot (#3453).
     // All models cost the same per request, so downgrading to a cheaper
@@ -115,7 +153,7 @@ export async function selectAndApplyModel(
     // Fail-closed: if primary model can't be resolved, fall back to
     // provider-level signals rather than allowing unwanted downgrades.
     if (routingConfig.enabled) {
-      const primaryModel = resolveModelId(modelConfig.primary, availableModels, ctx.model?.provider);
+      const primaryModel = resolveModelId(modelConfig.primary, routingEligibleModels, ctx.model?.provider);
       if (primaryModel) {
         const primaryFlatRateCtx = buildFlatRateContext(primaryModel.provider, ctx, prefs);
         if (isFlatRateProvider(primaryModel.provider, primaryFlatRateCtx)) {
@@ -149,8 +187,14 @@ export async function selectAndApplyModel(
       const shouldClassify = !isHook || routingConfig.hooks !== false;
 
       if (shouldClassify) {
-        let classification = classifyUnitComplexity(unitType, unitId, basePath, budgetPct);
-        const availableModelIds = availableModels.map(m => m.id);
+        let classification = classifyUnitComplexity(
+          unitType,
+          unitId,
+          basePath,
+          budgetPct,
+          taskMetadataForPolicy,
+        );
+        const availableModelIds = routingEligibleModels.map(m => m.id);
 
         // Escalate tier on retry when escalate_on_failure is enabled (default: true)
         if (
@@ -257,15 +301,28 @@ export async function selectAndApplyModel(
     }
 
     const modelsToTry = [effectiveModelConfig.primary, ...effectiveModelConfig.fallbacks];
+    let attemptedPolicyEligible = false;
 
     for (const modelId of modelsToTry) {
-      const model = resolveModelId(modelId, availableModels, ctx.model?.provider);
+      const resolutionPool = uokFlags.modelPolicy ? routingEligibleModels : availableModels;
+      const model = resolveModelId(modelId, resolutionPool, ctx.model?.provider);
 
       if (!model) {
         if (verbose) ctx.ui.notify(`Model ${modelId} not found, trying fallback.`, "info");
         continue;
       }
 
+      if (policyAllowedModelKeys) {
+        const key = `${model.provider.toLowerCase()}/${model.id.toLowerCase()}`;
+        if (!policyAllowedModelKeys.has(key)) {
+          if (verbose) {
+            ctx.ui.notify(`Model policy denied ${model.provider}/${model.id}; trying fallback.`, "warning");
+          }
+          continue;
+        }
+        attemptedPolicyEligible = true;
+      }
+
       // Warn if the ID is ambiguous across providers
       if (!modelId.includes("/")) {
         const providers = availableModels.filter(m => m.id === modelId).map(m => m.provider);
@@ -331,6 +388,10 @@ export async function selectAndApplyModel(
         }
       }
     }
+
+    if (uokFlags.modelPolicy && policyAllowedModelKeys && !attemptedPolicyEligible) {
+      throw new Error(`Model policy denied dispatch for ${unitType}/${unitId} before prompt send`);
+    }
   } else if (autoModeStartModel) {
     // No model preference for this unit type — re-apply the model captured
     // at auto-mode start to prevent bleed from shared global settings.json (#650).

package/src/resources/extensions/gsd/auto-post-unit.ts

@@ -29,9 +29,10 @@ import { rebuildState } from "./doctor.js";
 import { parseUnitId } from "./unit-id.js";
 import { closeoutUnit, type CloseoutOptions } from "./auto-unit-closeout.js";
 import {
-  autoCommitCurrentBranch,
+  runTurnGitAction,
   type TaskCommitContext,
-} from "./worktree.js";
+  type TurnGitActionMode,
+} from "./git-service.js";
 import {
   verifyExpectedArtifact,
   resolveExpectedArtifactPath,
@@ -66,6 +67,9 @@ import { getSliceTasks } from "./gsd-db.js";
 import { runPreExecutionChecks, type PreExecutionResult } from "./pre-execution-checks.js";
 import { writePreExecutionEvidence } from "./verification-evidence.js";
 import { ensureCodebaseMapFresh } from "./codebase-generator.js";
+import { resolveUokFlags } from "./uok/flags.js";
+import { UokGateRunner } from "./uok/gate-runner.js";
+import { writeTurnGitTransaction } from "./uok/gitops.js";
 
 /** Maximum verification retry attempts before escalating to blocker placeholder (#2653). */
 const MAX_VERIFICATION_RETRIES = 3;
@@ -109,6 +113,7 @@ import {
 import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { _resetHasChangesCache } from "./native-git-bridge.js";
+import { autoCommitCurrentBranch } from "./worktree.js";
 
 // ─── Rogue File Detection ──────────────────────────────────────────────────
 
@@ -262,6 +267,65 @@ export interface PostUnitContext {
   updateProgressWidget: (ctx: ExtensionContext, unitType: string, unitId: string, state: import("./types.js").GSDState) => void;
 }
 
+export async function autoCommitUnit(
+  basePath: string,
+  unitType: string,
+  unitId: string,
+  ctx?: ExtensionContext,
+): Promise<string | null> {
+  try {
+    let taskContext: TaskCommitContext | undefined;
+
+    if (unitType === "execute-task") {
+      const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+      if (mid && sid && tid) {
+        const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+        if (summaryPath) {
+          try {
+            const summaryContent = await loadFile(summaryPath);
+            if (summaryContent) {
+              const summary = parseSummary(summaryContent);
+              let ghIssueNumber: number | undefined;
+              try {
+                const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
+                ghIssueNumber = getTaskIssueNumberForCommit(basePath, mid, sid, tid) ?? undefined;
+              } catch (err) {
+                logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+              }
+
+              taskContext = {
+                taskId: `${sid}/${tid}`,
+                taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
+                oneLiner: summary.oneLiner || undefined,
+                keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
+                issueNumber: ghIssueNumber,
+              };
+            }
+          } catch (e) {
+            debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
+          }
+        }
+      }
+    }
+
+    _resetHasChangesCache();
+
+    if (LIFECYCLE_ONLY_UNITS.has(unitType)) {
+      return null;
+    }
+
+    const commitMsg = autoCommitCurrentBranch(basePath, unitType, unitId, taskContext);
+    if (commitMsg) {
+      ctx?.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
+    }
+    return commitMsg;
+  } catch (e) {
+    debugLog("postUnit", { phase: "auto-commit", error: String(e) });
+    ctx?.ui.notify(`Auto-commit failed: ${String(e).split("\n")[0]}`, "warning");
+    return null;
+  }
+}
+
 /**
  * Pre-verification processing: parallel worker signal check, cache invalidation,
  * auto-commit, doctor run, state rebuild, worktree sync, artifact verification.
@@ -298,13 +362,21 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
     await new Promise(r => setTimeout(r, 100));
   }
 
-  // Auto-commit
+  const prefs = loadEffectiveGSDPreferences()?.preferences;
+  const uokFlags = resolveUokFlags(prefs);
+
+  // Turn-level git action (commit | snapshot | status-only)
   if (s.currentUnit) {
     const unit = s.currentUnit;
+    const turnAction: TurnGitActionMode = uokFlags.gitops ? uokFlags.gitopsTurnAction : "commit";
+    const traceId = s.currentTraceId ?? `turn:${unit.startedAt}`;
+    const turnId = s.currentTurnId ?? `${unit.type}/${unit.id}/${unit.startedAt}`;
+    s.lastGitActionFailure = null;
+    s.lastGitActionStatus = null;
     try {
       let taskContext: TaskCommitContext | undefined;
 
-      if (s.currentUnit.type === "execute-task") {
+      if (turnAction === "commit" && s.currentUnit.type === "execute-task") {
         const { milestone: mid, slice: sid, task: tid } = parseUnitId(s.currentUnit.id);
         if (mid && sid && tid) {
           const summaryPath = resolveTaskFile(s.basePath, mid, sid, tid, "SUMMARY");
@@ -345,18 +417,105 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
       // `git worktree remove --force` during teardown.
       _resetHasChangesCache();
 
-      // Skip auto-commit for lifecycle-only units (#2553) — they only touch
-      // `.gsd/` internal state files. Those files are picked up by the next
-      // actual task commit via smartStage().
-      if (!LIFECYCLE_ONLY_UNITS.has(s.currentUnit.type)) {
-        const commitMsg = autoCommitCurrentBranch(s.basePath, s.currentUnit.type, s.currentUnit.id, taskContext);
-        if (commitMsg) {
-          ctx.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
+      const skipLifecycleCommit =
+        turnAction === "commit" && LIFECYCLE_ONLY_UNITS.has(s.currentUnit.type);
+
+      if (skipLifecycleCommit) {
+        debugLog("postUnit", {
+          phase: "git-action-skipped",
+          reason: "lifecycle-only-unit",
+          unitType: s.currentUnit.type,
+          unitId: s.currentUnit.id,
+        });
+      } else {
+        const gitResult = runTurnGitAction({
+          basePath: s.basePath,
+          action: turnAction,
+          unitType: s.currentUnit.type,
+          unitId: s.currentUnit.id,
+          taskContext,
+        });
+
+        if (uokFlags.gitops) {
+          writeTurnGitTransaction({
+            basePath: s.basePath,
+            traceId,
+            turnId,
+            unitType: unit.type,
+            unitId: unit.id,
+            stage: "publish",
+            action: turnAction,
+            push: uokFlags.gitopsTurnPush,
+            status: gitResult.status,
+            error: gitResult.error,
+            metadata: {
+              dirty: gitResult.dirty,
+              commitMessage: gitResult.commitMessage,
+              snapshotLabel: gitResult.snapshotLabel,
+            },
+          });
+        }
+
+        if (gitResult.status === "failed") {
+          s.lastGitActionFailure = gitResult.error ?? `git ${turnAction} failed`;
+          s.lastGitActionStatus = "failed";
+          if (uokFlags.gitops && uokFlags.gates) {
+            const parsed = parseUnitId(unit.id);
+            const gateRunner = new UokGateRunner();
+            gateRunner.register({
+              id: "closeout-git-action",
+              type: "closeout",
+              execute: async () => ({
+                outcome: "fail",
+                failureClass: "git",
+                rationale: `turn git action "${turnAction}" failed`,
+                findings: gitResult.error ?? "unknown git failure",
+              }),
+            });
+            await gateRunner.run("closeout-git-action", {
+              basePath: s.basePath,
+              traceId,
+              turnId,
+              milestoneId: parsed.milestone ?? undefined,
+              sliceId: parsed.slice ?? undefined,
+              taskId: parsed.task ?? undefined,
+              unitType: unit.type,
+              unitId: unit.id,
+            });
+          }
+
+          const failureMsg = `Git ${turnAction} failed: ${(gitResult.error ?? "unknown error").split("\n")[0]}`;
+          if (uokFlags.gitops) {
+            ctx.ui.notify(failureMsg, "error");
+            await pauseAuto(ctx, pi);
+            return "dispatched";
+          }
+          ctx.ui.notify(failureMsg, "warning");
+          debugLog("postUnit", {
+            phase: "git-action-failed-nonblocking",
+            action: turnAction,
+            error: gitResult.error ?? "unknown error",
+          });
+        }
+
+        s.lastGitActionStatus = "ok";
+
+        if (turnAction === "commit" && gitResult.commitMessage) {
+          ctx.ui.notify(`Committed: ${gitResult.commitMessage.split("\n")[0]}`, "info");
+        } else if (turnAction === "snapshot" && gitResult.snapshotLabel) {
+          ctx.ui.notify(`Snapshot recorded: ${gitResult.snapshotLabel}`, "info");
         }
       }
     } catch (e) {
-      debugLog("postUnit", { phase: "auto-commit", error: String(e) });
-      ctx.ui.notify(`Auto-commit failed: ${String(e).split("\n")[0]}`, "warning");
+      const message = e instanceof Error ? e.message : String(e);
+      s.lastGitActionFailure = message;
+      s.lastGitActionStatus = "failed";
+      debugLog("postUnit", { phase: "git-action", error: message, action: turnAction });
+      ctx.ui.notify(`Git ${turnAction} failed: ${message.split("\n")[0]}`, uokFlags.gitops ? "error" : "warning");
+      if (uokFlags.gitops) {
+        await pauseAuto(ctx, pi);
+        return "dispatched";
+      }
     }
 
     // GitHub sync (non-blocking, opt-in)
@@ -866,11 +1025,13 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
     s.currentUnit &&
     s.currentUnit.type === "plan-slice"
   ) {
+    const currentUnit = s.currentUnit;
     let preExecPauseNeeded = false;
     await runSafely("postUnitPostVerification", "pre-execution-checks", async () => {
+      const prefs = loadEffectiveGSDPreferences()?.preferences;
+      const uokFlags = resolveUokFlags(prefs);
       try {
         // Check preferences — respect enhanced_verification and enhanced_verification_pre
-        const prefs = loadEffectiveGSDPreferences()?.preferences;
         const enhancedEnabled = prefs?.enhanced_verification !== false; // default true
         const preEnabled = prefs?.enhanced_verification_pre !== false;  // default true
 
@@ -884,7 +1045,7 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
         }
 
         // Parse the unit ID to get milestone/slice IDs
-        const { milestone: mid, slice: sid } = parseUnitId(s.currentUnit!.id);
+        const { milestone: mid, slice: sid } = parseUnitId(currentUnit.id);
         if (!mid || !sid) {
           debugLog("postUnitPostVerification", {
             phase: "pre-execution-checks",
@@ -905,6 +1066,8 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
           return;
         }
 
+        const strictMode = prefs?.enhanced_verification_strict === true;
+
         // Run pre-execution checks
         const result: PreExecutionResult = await runPreExecutionChecks(tasks, s.basePath);
 
@@ -928,11 +1091,45 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
           writePreExecutionEvidence(result, slicePath, mid, sid);
         }
 
-        // Notify UI
+        if (uokFlags.gates) {
+          const failedChecks = result.checks
+            .filter((check) => !check.passed)
+            .map((check) => `[${check.category}] ${check.target}: ${check.message}`);
+          const warnEscalated = result.status === "warn" && strictMode;
+          const blockingFailure = result.status === "fail" || warnEscalated;
+          const gateRunner = new UokGateRunner();
+          gateRunner.register({
+            id: "pre-execution-checks",
+            type: "input",
+            execute: async () => ({
+              outcome: blockingFailure ? "fail" : "pass",
+              failureClass: result.status === "fail" ? "input" : warnEscalated ? "policy" : "none",
+              rationale: blockingFailure
+                ? `pre-execution checks ${result.status}${warnEscalated ? " (strict)" : ""}`
+                : "pre-execution checks passed",
+              findings: failedChecks.join("\n"),
+            }),
+          });
+          await gateRunner.run("pre-execution-checks", {
+            basePath: s.basePath,
+            traceId: `pre-execution:${currentUnit.id}`,
+            turnId: currentUnit.id,
+            milestoneId: mid,
+            sliceId: sid,
+            unitType: currentUnit.type,
+            unitId: currentUnit.id,
+          });
+        }
+
+        // Notify UI — surface actionable details (#4259)
         if (result.status === "fail") {
-          const blockingCount = result.checks.filter(c => !c.passed && c.blocking).length;
+          const blockingChecks = result.checks.filter(c => !c.passed && c.blocking);
+          const blockingCount = blockingChecks.length;
+          const details = blockingChecks.slice(0, 3).map(c => `  \u2022 ${c.message}`).join("\n");
+          const suffix = blockingChecks.length > 3 ? `\n  \u2022 ...and ${blockingChecks.length - 3} more` : "";
+          const evidenceNote = `\nSee ${sid}-PRE-EXEC-VERIFY.json for full details.`;
           ctx.ui.notify(
-            `Pre-execution checks failed: ${blockingCount} blocking issue${blockingCount === 1 ? "" : "s"} found`,
+            `Pre-execution checks failed: ${blockingCount} blocking issue${blockingCount === 1 ? "" : "s"} found\n${details}${suffix}${evidenceNote}`,
             "error",
           );
           preExecPauseNeeded = true;
@@ -966,6 +1163,29 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
           `Pre-execution checks error: ${errorMessage} — pausing for human review`,
           "error",
         );
+        if (uokFlags.gates && s.currentUnit) {
+          const { milestone: mid, slice: sid } = parseUnitId(s.currentUnit.id);
+          const gateRunner = new UokGateRunner();
+          gateRunner.register({
+            id: "pre-execution-checks",
+            type: "input",
+            execute: async () => ({
+              outcome: "manual-attention",
+              failureClass: "manual-attention",
+              rationale: "pre-execution checks threw before completion",
+              findings: errorMessage,
+            }),
+          });
+          await gateRunner.run("pre-execution-checks", {
+            basePath: s.basePath,
+            traceId: `pre-execution:${s.currentUnit.id}`,
+            turnId: s.currentUnit.id,
+            milestoneId: mid ?? undefined,
+            sliceId: sid ?? undefined,
+            unitType: s.currentUnit.type,
+            unitId: s.currentUnit.id,
+          });
+        }
         preExecPauseNeeded = true;
       }
     });

package/src/resources/extensions/gsd/auto-prompts.ts

@@ -34,6 +34,7 @@ import {
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
 import { readPhaseAnchor, formatAnchorForPrompt } from "./phase-anchor.js";
 import { logWarning } from "./workflow-logger.js";
+import { inlineGraphSubgraph } from "./graph-context.js";
 
 // ─── Preamble Cap ─────────────────────────────────────────────────────────────
 
@@ -1175,6 +1176,10 @@ export async function buildResearchSlicePrompt(
   const knowledgeInlineRS = await inlineKnowledgeScoped(base, keywords);
   if (knowledgeInlineRS) inlined.push(knowledgeInlineRS);
 
+  // Knowledge graph: subgraph for this slice (graceful — skipped if no graph.json)
+  const graphBlockRS = await inlineGraphSubgraph(base, `${sid} ${sTitle}`, { budget: 3000 });
+  if (graphBlockRS) inlined.push(graphBlockRS);
+
   inlined.push(inlineTemplate("research", "Research"));
 
   const depContent = await inlineDependencySummaries(mid, sid, base);
@@ -1250,6 +1255,10 @@ export async function buildPlanSlicePrompt(
   const knowledgeInlinePS = await inlineKnowledgeScoped(base, keywordsPS);
   if (knowledgeInlinePS) inlined.push(knowledgeInlinePS);
 
+  // Knowledge graph: subgraph for this slice (graceful — skipped if no graph.json)
+  const graphBlockPS = await inlineGraphSubgraph(base, `${sid} ${sTitle}`, { budget: 3000 });
+  if (graphBlockPS) inlined.push(graphBlockPS);
+
   inlined.push(inlineTemplate("plan", "Slice Plan"));
   if (inlineLevel === "full") {
     inlined.push(inlineTemplate("task-plan", "Task Plan"));
@@ -1366,12 +1375,16 @@ export async function buildExecuteTaskPrompt(
   // Only include if it has content (not a "not found" result)
   const knowledgeContent = knowledgeInlineET && !knowledgeInlineET.includes("not found") ? knowledgeInlineET : null;
 
+  // Knowledge graph: tight subgraph for this task (graceful — skipped if no graph.json)
+  const graphBlockET = await inlineGraphSubgraph(base, `${tid} ${tTitle}`, { budget: 2000 });
+
   const inlinedTemplates = inlineLevel === "minimal"
     ? inlineTemplate("task-summary", "Task Summary")
     : [
         inlineTemplate("task-summary", "Task Summary"),
         inlineTemplate("decisions", "Decisions"),
         ...(knowledgeContent ? [knowledgeContent] : []),
+        ...(graphBlockET ? [graphBlockET] : []),
       ].join("\n\n---\n\n");
 
   const taskSummaryPath = join(base, `${relSlicePath(base, mid, sid)}/tasks/${tid}-SUMMARY.md`);

package/src/resources/extensions/gsd/auto-unit-closeout.ts

@@ -8,6 +8,7 @@ import type { ExtensionContext } from "@gsd/pi-coding-agent";
 import { snapshotUnitMetrics } from "./metrics.js";
 import { saveActivityLog } from "./activity-log.js";
 import { logWarning } from "./workflow-logger.js";
+import { writeTurnGitTransaction } from "./uok/gitops.js";
 
 export interface CloseoutOptions {
   promptCharCount?: number;
@@ -15,6 +16,12 @@ export interface CloseoutOptions {
   tier?: string;
   modelDowngraded?: boolean;
   continueHereFired?: boolean;
+  traceId?: string;
+  turnId?: string;
+  gitAction?: "commit" | "snapshot" | "status-only";
+  gitPush?: boolean;
+  gitStatus?: "ok" | "failed";
+  gitError?: string;
 }
 
 /**
@@ -47,6 +54,23 @@ export async function closeoutUnit(
     }
   }
 
+  if (opts?.traceId && opts.turnId && opts.gitAction && opts.gitStatus) {
+    writeTurnGitTransaction({
+      basePath,
+      traceId: opts.traceId,
+      turnId: opts.turnId,
+      unitType,
+      unitId,
+      stage: "record",
+      action: opts.gitAction,
+      push: opts.gitPush === true,
+      status: opts.gitStatus,
+      error: opts.gitError,
+      metadata: {
+        activityFile,
+      },
+    });
+  }
+
   return activityFile ?? undefined;
 }
-