@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.84c56d87

package/src/resources/extensions/gsd/provider-payload-policy.ts

@@ -0,0 +1,140 @@
+/**
+ * Provider Payload Policy - ordered shaping of provider request payloads.
+ *
+ * The order is intentional:
+ * 1. observation budgeting masks old tool results in auto-mode,
+ * 2. display truncation caps tool-result text for every mode,
+ * 3. the protected Source Context Block is appended after truncation,
+ * 4. supported models receive the configured service tier.
+ */
+
+import type { ContextManagementConfig } from "./preferences-types.js";
+import type { ServiceTierSetting } from "./service-tier.js";
+
+import {
+  createObservationMask,
+  createResponsesInputObservationMask,
+  truncateContextResultMessages,
+  truncateResponsesInputResultItems,
+} from "./context-masker.js";
+import { getSourceObservationStore, isAutoActive } from "./auto-runtime-state.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { getEffectiveServiceTier, supportsServiceTier } from "./service-tier.js";
+import { injectSourceContextBlockIntoPayload } from "./source-observations.js";
+
+const DEFAULT_OBSERVATION_MASK_TURNS = 8;
+const DEFAULT_TOOL_RESULT_MAX_CHARS = 800;
+
+type MessagePayload = Parameters<ReturnType<typeof createObservationMask>>[0];
+type ResponsesInputPayload = Parameters<ReturnType<typeof createResponsesInputObservationMask>>[0];
+
+export interface ProviderPayloadPolicyDeps {
+  isAutoActive(): boolean;
+  loadContextManagementConfig(): ContextManagementConfig | undefined;
+  renderSourceContextBlock(): string | null;
+  getEffectiveServiceTier(): ServiceTierSetting;
+  supportsServiceTier(modelId: string): boolean;
+}
+
+export interface ProviderPayloadPolicyInput {
+  payload: Record<string, unknown>;
+  modelId?: string;
+  deps?: Partial<ProviderPayloadPolicyDeps>;
+}
+
+export const DEFAULT_PROVIDER_PAYLOAD_POLICY_DEPS: ProviderPayloadPolicyDeps = {
+  isAutoActive,
+  loadContextManagementConfig: () => loadEffectiveGSDPreferences()?.preferences.context_management,
+  renderSourceContextBlock: () => getSourceObservationStore().renderActiveBlock(),
+  getEffectiveServiceTier,
+  supportsServiceTier,
+};
+
+export function applyProviderPayloadPolicy({
+  payload,
+  modelId,
+  deps: overrides,
+}: ProviderPayloadPolicyInput): Record<string, unknown> {
+  const deps = { ...DEFAULT_PROVIDER_PAYLOAD_POLICY_DEPS, ...overrides };
+
+  try {
+    applyContextManagement(payload, deps);
+  } catch {
+    // Provider payload shaping should not block a request when optional
+    // context management preferences or adapters fail.
+  }
+
+  try {
+    applySourceContextBlock(payload, deps);
+  } catch {
+    // Source observations are opportunistic; execution can continue without
+    // an injected block.
+  }
+
+  applyServiceTier(payload, modelId, deps);
+  return payload;
+}
+
+function applyContextManagement(
+  payload: Record<string, unknown>,
+  deps: ProviderPayloadPolicyDeps,
+): void {
+  const config = deps.loadContextManagementConfig();
+  applyObservationBudget(payload, config, deps.isAutoActive());
+  applyDisplayTruncation(payload, config);
+}
+
+function applyObservationBudget(
+  payload: Record<string, unknown>,
+  config: ContextManagementConfig | undefined,
+  autoActive: boolean,
+): void {
+  if (!autoActive || config?.observation_masking === false) return;
+
+  const keepTurns = config?.observation_mask_turns ?? DEFAULT_OBSERVATION_MASK_TURNS;
+  if (Array.isArray(payload.messages)) {
+    payload.messages = createObservationMask(keepTurns)(payload.messages as MessagePayload);
+  }
+  if (Array.isArray(payload.input)) {
+    payload.input = createResponsesInputObservationMask(keepTurns)(payload.input as ResponsesInputPayload);
+  }
+}
+
+function applyDisplayTruncation(
+  payload: Record<string, unknown>,
+  config: ContextManagementConfig | undefined,
+): void {
+  const maxChars = config?.tool_result_max_chars ?? DEFAULT_TOOL_RESULT_MAX_CHARS;
+
+  if (Array.isArray(payload.messages)) {
+    payload.messages = truncateContextResultMessages(payload.messages as MessagePayload, maxChars);
+  }
+  if (Array.isArray(payload.input)) {
+    payload.input = truncateResponsesInputResultItems(payload.input as ResponsesInputPayload, maxChars);
+  }
+}
+
+function applySourceContextBlock(
+  payload: Record<string, unknown>,
+  deps: ProviderPayloadPolicyDeps,
+): void {
+  if (!deps.isAutoActive()) return;
+
+  const sourceContextBlock = deps.renderSourceContextBlock();
+  if (!sourceContextBlock) return;
+
+  Object.assign(payload, injectSourceContextBlockIntoPayload(payload, sourceContextBlock));
+}
+
+function applyServiceTier(
+  payload: Record<string, unknown>,
+  modelId: string | undefined,
+  deps: ProviderPayloadPolicyDeps,
+): void {
+  if (!modelId) return;
+
+  const tier = deps.getEffectiveServiceTier();
+  if (!tier || !deps.supportsServiceTier(modelId)) return;
+
+  payload.service_tier = tier;
+}

package/src/resources/extensions/gsd/provider-switch-observer.ts

@@ -128,7 +128,7 @@ function emitAudit(report: ProviderSwitchReport): void {
 
 function emitNotification(report: ProviderSwitchReport): void {
   try {
-    appendNotification(summarize(report), "warning", "workflow-logger");
+    appendNotification(summarize(report), "warning", "workflow-logger", { kind: "provider-switch" });
   } catch {
     // Notification persistence is best-effort.
   }

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

@@ -0,0 +1,122 @@
+// Project/App: gsd-pi
+// File Purpose: Publication module — push and draft-PR creation for a merged milestone (ADR-034).
+//
+// Publication is distinct from the merge verb: merging a milestone branch is a
+// Worktree Lifecycle concern (worktree, branch, lease, stash discipline);
+// publication needs only the resulting commit, a remote, and preferences.
+// Extracted from the tail of `mergeMilestoneToMain` (auto-worktree.ts) so it is
+// testable without a merge fixture and reachable from any closeout path.
+//
+// Publication failure is non-fatal to a completed local merge: every failure is
+// logged and reported in the result, never thrown.
+
+import { execFileSync } from "node:child_process";
+
+import {
+  buildPullRequestEvidence,
+  createDraftPullRequestFromEvidence,
+} from "./pull-request-process.js";
+import { logWarning } from "./workflow-logger.js";
+
+export interface PublicationPrefs {
+  autoPush: boolean;
+  autoPr: boolean;
+  remote?: string;
+  prTargetBranch?: string;
+}
+
+export interface PublicationRequest {
+  basePath: string;
+  milestoneId: string;
+  milestoneTitle: string;
+  /** The branch the milestone was merged to (push target for auto-push). */
+  integrationBranch: string;
+  /** The milestone branch (push + PR head for auto-PR). */
+  milestoneBranch: string;
+  /** Pre-rendered per-slice summary blocks for the PR body. */
+  sliceSummaries: readonly string[];
+  /** True when the merge found nothing to commit — publication is skipped. */
+  nothingToCommit: boolean;
+  prefs: PublicationPrefs;
+}
+
+export interface PublicationResult {
+  pushed: boolean;
+  prCreated: boolean;
+  prUrl?: string;
+}
+
+export function gitRemoteExists(basePath: string, remote: string): boolean {
+  try {
+    execFileSync("git", ["remote", "get-url", remote], {
+      cwd: basePath,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Publish a merged milestone per preferences: push the integration branch
+ * (auto-push, suppressed when auto-PR owns the remote interaction) and/or
+ * push the milestone branch and open a draft PR (auto-PR).
+ */
+export function publishMilestone(request: PublicationRequest): PublicationResult {
+  const result: PublicationResult = { pushed: false, prCreated: false };
+  if (request.nothingToCommit) return result;
+
+  const { basePath, prefs } = request;
+  const remote = prefs.remote ?? "origin";
+
+  if (prefs.autoPush && !prefs.autoPr && gitRemoteExists(basePath, remote)) {
+    try {
+      execFileSync("git", ["push", remote, request.integrationBranch], {
+        cwd: basePath,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+      });
+      result.pushed = true;
+    } catch (err) {
+      // Push failure is non-fatal
+      logWarning("worktree", `git push failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+
+  // #2302: PR creation is not gated on pushed/auto-push.
+  if (prefs.autoPr && gitRemoteExists(basePath, remote)) {
+    try {
+      // Push the milestone branch to remote first
+      execFileSync("git", ["push", remote, request.milestoneBranch], {
+        cwd: basePath,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+      });
+      const prEvidence = buildPullRequestEvidence({
+        milestoneId: request.milestoneId,
+        milestoneTitle: request.milestoneTitle,
+        changeType: "feat",
+        summaries: [...request.sliceSummaries],
+        testsRun: ["Auto-created after milestone merge. Run `npm run verify:merge` before marking this draft ready."],
+        rollbackNotes: ["Close the draft PR or revert the merge commit if review finds a behavior regression."],
+        how: "Generated by git.auto_pr after the milestone branch was pushed and merged locally.",
+      });
+      const prUrl = createDraftPullRequestFromEvidence(basePath, request.milestoneId, prEvidence, {
+        head: request.milestoneBranch,
+        base: prefs.prTargetBranch ?? request.integrationBranch,
+      });
+      if (!prUrl) {
+        throw new Error("gh pr create returned no URL");
+      }
+      result.prCreated = true;
+      result.prUrl = prUrl;
+    } catch (err) {
+      // PR creation failure is non-fatal — gh may not be installed or authenticated
+      logWarning("worktree", `PR creation failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+
+  return result;
+}

package/src/resources/extensions/gsd/pull-request-process.ts

@@ -0,0 +1,41 @@
+// Project/App: gsd-pi
+// File Purpose: Process-level pull request policy for GSD-generated PRs.
+
+import { createDraftPR } from "./git-service.js";
+import {
+  buildPrEvidence,
+  type PrEvidence,
+  type PrEvidenceInput,
+} from "./pr-evidence.js";
+
+export interface DraftPullRequestOptions {
+  head: string;
+  base: string;
+}
+
+export interface DraftPullRequestDeps {
+  createDraftPR: (
+    basePath: string,
+    milestoneId: string,
+    title: string,
+    body: string,
+    opts: DraftPullRequestOptions,
+  ) => string | null;
+}
+
+export function buildPullRequestEvidence(input: PrEvidenceInput): PrEvidence {
+  return buildPrEvidence({
+    ...input,
+    aiAssisted: false,
+  });
+}
+
+export function createDraftPullRequestFromEvidence(
+  basePath: string,
+  milestoneId: string,
+  evidence: PrEvidence,
+  options: DraftPullRequestOptions,
+  deps: DraftPullRequestDeps = { createDraftPR },
+): string | null {
+  return deps.createDraftPR(basePath, milestoneId, evidence.title, evidence.body, options);
+}

package/src/resources/extensions/gsd/quality-gate-closure.ts

@@ -0,0 +1,140 @@
+// Project/App: gsd-pi
+// File Purpose: Canonical quality-gate closure from durable DB and artifact evidence.
+
+import { existsSync, readFileSync } from "node:fs";
+
+import { extractSection } from "./files.js";
+import { getGateDefinition } from "./gate-registry.js";
+import { getMilestoneSlices, getPendingGates, saveGateResult } from "./gsd-db.js";
+import { resolveSliceFile, resolveTaskFile } from "./paths.js";
+import type { GateId, GateRow, GateVerdict } from "./types.js";
+
+export interface QualityGateClosureOptions {
+  artifactBasePath?: string;
+  milestoneValidationPassed?: boolean;
+}
+
+export interface QualityGateClosureResult {
+  repaired: Array<{ gateId: GateId; sliceId: string; taskId?: string; verdict: GateVerdict }>;
+  unresolved: GateRow[];
+}
+
+interface GateEvidence {
+  verdict: GateVerdict;
+  rationale: string;
+  findings: string;
+}
+
+const GATE_SECTION_HEADINGS: Partial<Record<GateId, string[]>> = {
+  Q3: ["Threat Surface", "Abuse Surface"],
+  Q4: ["Requirement Impact", "Broken Promises"],
+  Q5: ["Failure Modes"],
+  Q6: ["Load Profile"],
+  Q7: ["Negative Tests"],
+  Q8: ["Operational Readiness"],
+};
+
+function readFile(path: string | null): string | null {
+  if (!path || !existsSync(path)) return null;
+  return readFileSync(path, "utf-8");
+}
+
+function firstSection(content: string | null, gateId: GateId): string | null {
+  if (!content) return null;
+  for (const heading of GATE_SECTION_HEADINGS[gateId] ?? []) {
+    const section = extractSection(content, heading);
+    if (section) return section;
+  }
+  return null;
+}
+
+function evidenceArtifactContent(row: GateRow, basePath: string): string | null {
+  const def = getGateDefinition(row.gate_id);
+  switch (def?.ownerTurn) {
+    case "gate-evaluate":
+      return readFile(resolveSliceFile(basePath, row.milestone_id, row.slice_id, "PLAN"));
+    case "execute-task":
+      return readFile(resolveTaskFile(basePath, row.milestone_id, row.slice_id, row.task_id, "SUMMARY"));
+    case "complete-slice":
+      return readFile(resolveSliceFile(basePath, row.milestone_id, row.slice_id, "SUMMARY"));
+    default:
+      return null;
+  }
+}
+
+function closureEvidence(row: GateRow, options: QualityGateClosureOptions): GateEvidence | null {
+  const def = getGateDefinition(row.gate_id);
+  if (!def) return null;
+
+  if (def.ownerTurn === "validate-milestone" && options.milestoneValidationPassed) {
+    return {
+      verdict: "pass",
+      rationale: `${def.promptSection} covered by passing milestone validation`,
+      findings: "",
+    };
+  }
+
+  if (!options.artifactBasePath) return null;
+
+  const section = firstSection(evidenceArtifactContent(row, options.artifactBasePath), row.gate_id);
+  if (section) {
+    return {
+      verdict: "pass",
+      rationale: `${def.promptSection} evidence found in durable artifact`,
+      findings: section,
+    };
+  }
+
+  if (!options.milestoneValidationPassed) return null;
+  return {
+    verdict: "omitted",
+    rationale: `${def.promptSection} has no durable artifact section; milestone validation passed`,
+    findings: "",
+  };
+}
+
+function closeGate(row: GateRow, evidence: GateEvidence): void {
+  saveGateResult({
+    milestoneId: row.milestone_id,
+    sliceId: row.slice_id,
+    gateId: row.gate_id,
+    taskId: row.task_id,
+    verdict: evidence.verdict,
+    rationale: evidence.rationale,
+    findings: evidence.findings,
+  });
+}
+
+export function closeQualityGatesFromEvidence(
+  milestoneId: string,
+  options: QualityGateClosureOptions = {},
+): QualityGateClosureResult {
+  const repaired: QualityGateClosureResult["repaired"] = [];
+  const unresolved: GateRow[] = [];
+
+  for (const slice of getMilestoneSlices(milestoneId)) {
+    const sliceId = slice.id;
+    for (const row of getPendingGates(milestoneId, sliceId)) {
+      if (!getGateDefinition(row.gate_id)) {
+        unresolved.push(row);
+        continue;
+      }
+
+      const evidence = closureEvidence(row, options);
+      if (!evidence) {
+        unresolved.push(row);
+        continue;
+      }
+
+      closeGate(row, evidence);
+      repaired.push({
+        gateId: row.gate_id,
+        sliceId: row.slice_id,
+        ...(row.task_id ? { taskId: row.task_id } : {}),
+        verdict: evidence.verdict,
+      });
+    }
+  }
+
+  return { repaired, unresolved };
+}

package/src/resources/extensions/gsd/question-transport.ts

@@ -0,0 +1,138 @@
+// Project/App: gsd-pi
+// File Purpose: Resolve how workflow units should ask the user for input.
+
+import { parseMcpToolName, toMcpToolName } from "./mcp-tool-name.js";
+
+export type StructuredQuestionsFlag = "true" | "false";
+
+export interface QuestionTransportOptions {
+  activeTools: string[];
+  authMode?: "apiKey" | "oauth" | "externalCli" | "none";
+  baseUrl?: string;
+  env?: NodeJS.ProcessEnv;
+}
+
+export interface QuestionTransportResolution {
+  structuredQuestionsAvailable: StructuredQuestionsFlag;
+  questionToolAvailable: boolean;
+  usesWorkflowMcp: boolean;
+  reason: "question-tool-available" | "question-tool-missing" | "workflow-mcp-disabled";
+}
+
+export interface WorkflowQuestionToolSurfaceOptions {
+  workflowServerName?: string;
+  workflowExplicitlyBlocked?: boolean;
+  workflowMcpTools: string[];
+  exactWorkflowMcpTools: string[];
+  env?: NodeJS.ProcessEnv;
+}
+
+export interface WorkflowQuestionToolSurfaceResolution extends QuestionTransportResolution {
+  questionToolName?: string;
+  workflowQuestionsEnabled: boolean;
+  disallowedTools: string[];
+}
+
+function isWorkflowMcpServerName(serverName: string): boolean {
+  const normalized = serverName.toLowerCase();
+  return normalized === "gsd" || normalized.includes("workflow");
+}
+
+export function usesWorkflowMcpTransport(
+  authMode: QuestionTransportOptions["authMode"],
+  baseUrl: string | undefined,
+): boolean {
+  return authMode === "externalCli" && typeof baseUrl === "string" && baseUrl.startsWith("local://");
+}
+
+export function hasAskUserQuestionsTool(activeTools: string[]): boolean {
+  return activeTools.some((toolName) => {
+    if (toolName === "ask_user_questions") return true;
+    const mcp = parseMcpToolName(toolName);
+    if (!mcp) return false;
+    if (mcp.toolName === "ask_user_questions") return true;
+    return mcp.toolName === "*" && isWorkflowMcpServerName(mcp.serverName);
+  });
+}
+
+function workflowMcpStructuredQuestionsEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+  const value = env.GSD_WORKFLOW_MCP_STRUCTURED_QUESTIONS?.trim().toLowerCase();
+  return value !== "0" && value !== "false" && value !== "off";
+}
+
+export function resolveQuestionTransport(
+  options: QuestionTransportOptions,
+): QuestionTransportResolution {
+  const questionToolAvailable = hasAskUserQuestionsTool(options.activeTools);
+  const usesWorkflowMcp = usesWorkflowMcpTransport(options.authMode, options.baseUrl);
+
+  if (!questionToolAvailable) {
+    return {
+      structuredQuestionsAvailable: "false",
+      questionToolAvailable,
+      usesWorkflowMcp,
+      reason: "question-tool-missing",
+    };
+  }
+
+  if (options.authMode === "externalCli" && !workflowMcpStructuredQuestionsEnabled(options.env)) {
+    return {
+      structuredQuestionsAvailable: "false",
+      questionToolAvailable,
+      usesWorkflowMcp,
+      reason: "workflow-mcp-disabled",
+    };
+  }
+
+  return {
+    structuredQuestionsAvailable: "true",
+    questionToolAvailable,
+    usesWorkflowMcp,
+    reason: "question-tool-available",
+  };
+}
+
+export function supportsStructuredQuestions(
+  activeTools: string[],
+  options: Omit<QuestionTransportOptions, "activeTools"> = {},
+): boolean {
+  return resolveQuestionTransport({
+    ...options,
+    activeTools,
+  }).structuredQuestionsAvailable === "true";
+}
+
+export function resolveWorkflowQuestionToolSurface(
+  options: WorkflowQuestionToolSurfaceOptions,
+): WorkflowQuestionToolSurfaceResolution {
+  const questionToolName = options.workflowServerName && !options.workflowExplicitlyBlocked
+    ? toMcpToolName(options.workflowServerName, "ask_user_questions")
+    : undefined;
+  const activeTools = [
+    ...options.exactWorkflowMcpTools,
+    ...options.workflowMcpTools,
+    ...(questionToolName ? [questionToolName] : []),
+  ];
+  const transport = resolveQuestionTransport({
+    activeTools,
+    authMode: "externalCli",
+    baseUrl: "local://claude-code",
+    env: options.env,
+  });
+  const exactQuestionToolAllowed =
+    !!questionToolName && options.exactWorkflowMcpTools.includes(questionToolName);
+  const workflowQuestionsEnabled =
+    transport.structuredQuestionsAvailable === "true" &&
+    (options.workflowMcpTools.length > 0 || exactQuestionToolAllowed);
+  const disallowedTools =
+    options.workflowServerName && transport.questionToolAvailable && !workflowQuestionsEnabled
+      ? [toMcpToolName(options.workflowServerName, "ask_user_questions")]
+      : [];
+
+  return {
+    ...transport,
+    questionToolName,
+    workflowQuestionsEnabled,
+    disallowedTools,
+  };
+}