@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.8e6112e9

package/src/resources/extensions/gsd/tests/prompt-db.test.ts

@@ -7,6 +7,9 @@
 
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
 import {
   openDatabase,
   closeDatabase,
@@ -22,6 +25,17 @@ import {
   formatDecisionsForPrompt,
   formatRequirementsForPrompt,
 } from '../context-store.ts';
+import { inlineRequirementsFromDb } from '../auto-prompts.ts';
+import { migrateFromMarkdown } from '../md-importer.ts';
+
+function createDbProjectWithRequirements(content: string): { tmpDir: string; gsdDir: string } {
+  const tmpDir = mkdtempSync(join(tmpdir(), 'prompt-db-requirements-'));
+  const gsdDir = join(tmpDir, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+  writeFileSync(join(gsdDir, 'REQUIREMENTS.md'), content);
+  openDatabase(join(gsdDir, 'gsd.db'));
+  return { tmpDir, gsdDir };
+}
 
 // ═══════════════════════════════════════════════════════════════════════════
 // prompt-db: DB-aware decisions helper returns scoped content
@@ -182,6 +196,116 @@ console.log('\n=== prompt-db: fallback when DB unavailable ===');
   assert.deepStrictEqual(formattedReqs, '', 'formatRequirementsForPrompt returns empty for empty input');
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// prompt-db: DB-aware requirements helper does not fall back on empty DB rows
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('prompt-db: inlineRequirementsFromDb returns null instead of full file when DB query is empty', async () => {
+  const { tmpDir } = createDbProjectWithRequirements(
+    `# Requirements\n\nFULL FILE SHOULD NOT BE INLINED\n\n${'large requirement body\n'.repeat(500)}`,
+  );
+  try {
+    const inlined = await inlineRequirementsFromDb(tmpDir, 'M999', undefined, 'full');
+
+    assert.equal(inlined, null);
+  } finally {
+    closeDatabase();
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('prompt-db: inlineRequirementsFromDb cascades from empty milestone query to active requirements', async () => {
+  const { tmpDir } = createDbProjectWithRequirements(
+    '# Requirements\n\nFULL FILE SHOULD NOT BE INLINED\n',
+  );
+  try {
+    insertRequirement({
+      id: 'R001',
+      class: 'functional',
+      status: 'active',
+      description: 'active requirement for another milestone',
+      why: 'needed',
+      source: 'M001',
+      primary_owner: 'M001/S01',
+      supporting_slices: '',
+      validation: 'test',
+      notes: '',
+      full_content: '',
+      superseded_by: null,
+    });
+    insertRequirement({
+      id: 'R002',
+      class: 'functional',
+      status: 'validated',
+      description: 'validated requirement should not be active fallback',
+      why: 'already done',
+      source: 'M001',
+      primary_owner: 'M001/S02',
+      supporting_slices: '',
+      validation: 'done',
+      notes: '',
+      full_content: '',
+      superseded_by: null,
+    });
+
+    const inlined = await inlineRequirementsFromDb(tmpDir, 'M999', undefined, 'full');
+
+    assert.ok(inlined);
+    assert.match(inlined, /### Requirements/);
+    assert.match(inlined, /# Requirements \(compact\)/);
+    assert.match(inlined, /R001/);
+    assert.match(inlined, /active requirement for another milestone/);
+    assert.doesNotMatch(inlined, /R002/);
+    assert.doesNotMatch(inlined, /FULL FILE SHOULD NOT BE INLINED/);
+  } finally {
+    closeDatabase();
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('prompt-db: inlineRequirementsFromDb keeps active fallback compact for slice-scoped full calls', async () => {
+  const { tmpDir } = createDbProjectWithRequirements(
+    '# Requirements\n\nFULL FILE SHOULD NOT BE INLINED\n',
+  );
+  try {
+    insertRequirement({
+      id: 'R001',
+      class: 'functional',
+      status: 'active',
+      description: 'active requirement for another milestone',
+      why: 'needed',
+      source: 'M001',
+      primary_owner: 'M001/S01',
+      supporting_slices: '',
+      validation: 'test',
+      notes: '',
+      full_content: '',
+      superseded_by: null,
+    });
+
+    // Slice-scoped call at inlineLevel "full" with no matching rows for the
+    // milestone+slice or milestone-only queries. The cascade should land on
+    // status: "active" rows from another milestone, and those project-wide
+    // active rows must be formatted compactly even though sliceId is set —
+    // otherwise the full per-requirement markdown would be inlined for every
+    // active row across the project.
+    const inlined = await inlineRequirementsFromDb(tmpDir, 'M999', 'S99', 'full');
+
+    assert.ok(inlined);
+    assert.match(inlined, /### Requirements/);
+    assert.match(inlined, /# Requirements \(compact\)/);
+    assert.match(inlined, /R001/);
+    // Full per-requirement markdown is forbidden here — its hallmark fields
+    // (Class:/Status:/Why: as bolded list items) are emitted only by
+    // formatRequirementsForPrompt, never by formatRequirementsCompact.
+    assert.doesNotMatch(inlined, /\*\*Class:\*\*/);
+    assert.doesNotMatch(inlined, /FULL FILE SHOULD NOT BE INLINED/);
+  } finally {
+    closeDatabase();
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
 // ═══════════════════════════════════════════════════════════════════════════
 // prompt-db: scoped filtering reduces content vs unscoped
 // ═══════════════════════════════════════════════════════════════════════════
@@ -316,12 +440,6 @@ console.log('\n=== prompt-db: DB helpers wrapper format matches expected pattern
 // prompt-db: re-import updates DB when source markdown changes
 // ═══════════════════════════════════════════════════════════════════════════
 
-import { mkdtempSync, writeFileSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { migrateFromMarkdown } from '../md-importer.ts';
-
-
 describe('prompt-db', () => {
 test('prompt-db: re-import updates DB when source markdown changes', () => {
   // Create a temp dir simulating a project with .gsd/DECISIONS.md

package/src/resources/extensions/gsd/tests/provider-error-guidance.test.ts

@@ -3,10 +3,10 @@ import assert from "node:assert/strict";
 
 import { classifyError, isTransient } from "../error-classifier.ts";
 import {
-  formatProviderErrorGuidance,
   resolveProviderErrorGuidance,
   unitTypeToPrefsPhaseKey,
 } from "../provider-error-guidance.ts";
+import { formatGuidance } from "../guidance.ts";
 
 test("classifyError: Cloud Code Assist 400 invalid argument is model-error", () => {
   const result = classifyError(
@@ -75,8 +75,8 @@ test("resolveProviderErrorGuidance suggests gemini-3-flash for antigravity pro-h
   assert.ok(guidance.steps.some((step) => step.includes("fallbacks")));
 });
 
-test("formatProviderErrorGuidance numbers steps", () => {
-  const text = formatProviderErrorGuidance({
+test("formatGuidance numbers steps", () => {
+  const text = formatGuidance({
     summary: "Provider error on test/model.",
     steps: ["Change model", "Run /gsd next"],
   });

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -17,10 +17,8 @@ import {
   shouldDeferTransientErrorToCoreRetry,
   suppressTerminalDeletedWorktreeMessageEnd,
 } from "../bootstrap/agent-end-recovery.ts";
-import {
-  _buildCancelledUnitStopReason,
-  _classifyZeroToolProviderMessageForTest,
-} from "../auto/phases.ts";
+import { _buildCancelledUnitStopReason } from "../auto/phase-helpers.ts";
+import { _classifyZeroToolProviderMessageForTest } from "../auto/unit-phase.ts";
 import { autoSession } from "../auto-runtime-state.ts";
 import { getNextFallbackModel } from "../preferences.ts";
 // Zero-import module — imported by path rather than through the package
@@ -740,6 +738,15 @@ test("MAX_TRANSIENT_AUTO_RESUMES is at least 8 for sustained overload resilience
   );
 });
 
+// ── OpenAI-completions mid-stream cut (#577) ─────────────────────────────────
+
+test("classifyError: 'Stream ended without finish_reason' is transient network (#577)", () => {
+  const result = classifyError("Stream ended without finish_reason");
+  assert.ok(isTransient(result), "Stream ended without finish_reason must be transient");
+  assert.equal(result.kind, "network");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs > 0);
+});
+
 // ── Stream idle timeout / partial response (#4558) ──────────────────────────
 
 test("classifyError: 'Stream idle timeout - partial response received' is transient network", () => {

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

@@ -0,0 +1,165 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import type { ContextManagementConfig } from "../preferences-types.js";
+import type { ProviderPayloadPolicyDeps } from "../provider-payload-policy.js";
+
+import { applyProviderPayloadPolicy } from "../provider-payload-policy.js";
+
+function createDeps(
+  overrides: Partial<ProviderPayloadPolicyDeps> & {
+    context?: ContextManagementConfig | undefined;
+    autoActive?: boolean;
+    sourceContextBlock?: string | null;
+  } = {},
+): ProviderPayloadPolicyDeps {
+  return {
+    isAutoActive: () => overrides.autoActive ?? false,
+    loadContextManagementConfig: () => overrides.context,
+    renderSourceContextBlock: () => overrides.sourceContextBlock ?? null,
+    getEffectiveServiceTier: () => undefined,
+    supportsServiceTier: () => false,
+    ...overrides,
+  };
+}
+
+function textFromMessage(message: { content?: unknown }): string {
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const text = content.find((block): block is { text: string } => {
+    return Boolean(block && typeof block === "object" && "text" in block && typeof block.text === "string");
+  });
+  return text?.text ?? "";
+}
+
+test("provider payload policy truncates tool results outside auto-mode without masking", () => {
+  const messageText = "m".repeat(50);
+  const responsesOutput = "r".repeat(50);
+  const payload = {
+    messages: [
+      { role: "user", content: [{ type: "text", text: "keep me" }] },
+      { role: "toolResult", content: [{ type: "text", text: messageText }] },
+    ],
+    input: [
+      { role: "user", content: [{ type: "input_text", text: "keep me" }] },
+      { type: "function_call_output", call_id: "call_test", output: responsesOutput },
+    ],
+  };
+
+  applyProviderPayloadPolicy({
+    payload,
+    deps: createDeps({ context: { observation_mask_turns: 1, tool_result_max_chars: 10 } }),
+  });
+
+  const truncatedMessage = textFromMessage(payload.messages[1]);
+  const truncatedResponsesOutput = String(payload.input[1]?.output ?? "");
+  assert.match(truncatedMessage, /\[truncated\]/);
+  assert.match(truncatedResponsesOutput, /\[truncated\]/);
+  assert.doesNotMatch(truncatedMessage, /result masked/);
+  assert.doesNotMatch(truncatedResponsesOutput, /result masked/);
+});
+
+test("provider payload policy appends source context after masking and truncation", () => {
+  const sourceContextBlock = "## Source Context Block\n\n" + "full source text ".repeat(20);
+  const payload = {
+    messages: [
+      { role: "user", content: [{ type: "text", text: "old turn" }] },
+      { role: "toolResult", content: [{ type: "text", text: "old result ".repeat(20) }] },
+      { role: "assistant", content: [{ type: "text", text: "ok" }] },
+      { role: "user", content: [{ type: "text", text: "new turn" }] },
+      { role: "toolResult", content: [{ type: "text", text: "new result ".repeat(20) }] },
+    ],
+  };
+
+  applyProviderPayloadPolicy({
+    payload,
+    deps: createDeps({
+      autoActive: true,
+      context: { observation_mask_turns: 1, tool_result_max_chars: 80 },
+      sourceContextBlock,
+    }),
+  });
+
+  const oldResult = textFromMessage(payload.messages[1]);
+  const newResult = textFromMessage(payload.messages[4]);
+  const appendedContext = textFromMessage(payload.messages[payload.messages.length - 1]);
+
+  assert.match(oldResult, /result masked/);
+  assert.match(newResult, /\[truncated\]/);
+  assert.equal(appendedContext, sourceContextBlock);
+  assert.doesNotMatch(appendedContext, /\[truncated\]/);
+});
+
+test("provider payload policy applies ordering to Responses input payloads", () => {
+  const sourceContextBlock = "## Source Context Block\n\n" + "responses source text ".repeat(20);
+  const payload = {
+    input: [
+      { role: "user", content: [{ type: "input_text", text: "old turn" }] },
+      { type: "function_call_output", call_id: "call_old", output: "old result ".repeat(20) },
+      { type: "message", role: "assistant", content: [{ type: "output_text", text: "ok" }] },
+      { role: "user", content: [{ type: "input_text", text: "new turn" }] },
+      { type: "function_call_output", call_id: "call_new", output: "new result ".repeat(20) },
+    ],
+  };
+
+  applyProviderPayloadPolicy({
+    payload,
+    deps: createDeps({
+      autoActive: true,
+      context: { observation_mask_turns: 1, tool_result_max_chars: 80 },
+      sourceContextBlock,
+    }),
+  });
+
+  assert.match(String(payload.input[1]?.output ?? ""), /result masked/);
+  assert.match(String(payload.input[4]?.output ?? ""), /\[truncated\]/);
+  assert.equal(textFromMessage(payload.input[payload.input.length - 1]), sourceContextBlock);
+});
+
+test("provider payload policy replaces existing source context blocks", () => {
+  const payload = {
+    messages: [
+      { role: "user", content: [{ type: "text", text: "keep me" }] },
+      { role: "user", content: [{ type: "text", text: "## Source Context Block\n\nstale" }] },
+    ],
+  };
+
+  applyProviderPayloadPolicy({
+    payload,
+    deps: createDeps({
+      autoActive: true,
+      sourceContextBlock: "## Source Context Block\n\nfresh",
+    }),
+  });
+
+  const sourceMessages = payload.messages.filter((message) => {
+    return textFromMessage(message).startsWith("## Source Context Block");
+  });
+  assert.equal(sourceMessages.length, 1);
+  assert.equal(textFromMessage(sourceMessages[0]), "## Source Context Block\n\nfresh");
+});
+
+test("provider payload policy sets service tier only for supported models", () => {
+  const unsupported = {};
+  applyProviderPayloadPolicy({
+    payload: unsupported,
+    modelId: "claude-opus-4-6",
+    deps: createDeps({
+      getEffectiveServiceTier: () => "priority",
+      supportsServiceTier: (modelId) => modelId === "gpt-5.4",
+    }),
+  });
+  assert.equal("service_tier" in unsupported, false);
+
+  const supported: Record<string, unknown> = {};
+  applyProviderPayloadPolicy({
+    payload: supported,
+    modelId: "gpt-5.4",
+    deps: createDeps({
+      getEffectiveServiceTier: () => "priority",
+      supportsServiceTier: (modelId) => modelId === "gpt-5.4",
+    }),
+  });
+  assert.equal(supported.service_tier, "priority");
+});

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

@@ -0,0 +1,120 @@
+// gsd-pi — ADR-034 Publication module tests.
+//
+// Exercises publishMilestone against real local git fixtures (a bare repo as
+// the remote) — no network, no gh. The PR path is only tested up to its
+// non-fatal failure contract, since createDraftPullRequestFromEvidence shells
+// out to gh.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { rmSync } from "node:fs";
+import { join } from "node:path";
+
+import { gitRemoteExists, publishMilestone } from "../publication.ts";
+import { git, makeTempDir, makeTempRepo } from "./test-utils.ts";
+
+function makeRepoWithBareRemote(): { repo: string; bare: string; cleanup: () => void } {
+  const repo = makeTempRepo("gsd-publication-test-");
+  const bare = join(makeTempDir("gsd-publication-remote-"), "remote.git");
+  git(repo, "init", "--bare", bare);
+  git(repo, "remote", "add", "origin", bare);
+  return {
+    repo,
+    bare,
+    cleanup: () => {
+      rmSync(repo, { recursive: true, force: true });
+      rmSync(bare, { recursive: true, force: true });
+    },
+  };
+}
+
+const NO_PUBLISH_PREFS = { autoPush: false, autoPr: false };
+
+function makeRequest(repo: string, prefs: { autoPush: boolean; autoPr: boolean; remote?: string; prTargetBranch?: string }) {
+  return {
+    basePath: repo,
+    milestoneId: "M001",
+    milestoneTitle: "Test milestone",
+    integrationBranch: "main",
+    milestoneBranch: "milestone/M001",
+    sliceSummaries: ["### S01\nSlice one"],
+    nothingToCommit: false,
+    prefs,
+  };
+}
+
+test("gitRemoteExists distinguishes configured from missing remotes", () => {
+  const { repo, cleanup } = makeRepoWithBareRemote();
+  try {
+    assert.equal(gitRemoteExists(repo, "origin"), true);
+    assert.equal(gitRemoteExists(repo, "upstream"), false);
+  } finally {
+    cleanup();
+  }
+});
+
+test("auto-push pushes the integration branch to the remote", () => {
+  const { repo, bare, cleanup } = makeRepoWithBareRemote();
+  try {
+    const result = publishMilestone(makeRequest(repo, { autoPush: true, autoPr: false }));
+    assert.equal(result.pushed, true);
+    assert.equal(result.prCreated, false);
+    const remoteHeads = git(repo, "ls-remote", "--heads", bare);
+    assert.match(remoteHeads, /refs\/heads\/main/);
+  } finally {
+    cleanup();
+  }
+});
+
+test("auto-push is suppressed when auto-PR owns the remote interaction", () => {
+  const { repo, bare, cleanup } = makeRepoWithBareRemote();
+  try {
+    git(repo, "branch", "milestone/M001");
+    const result = publishMilestone(makeRequest(repo, { autoPush: true, autoPr: true }));
+    // PR creation pushes the milestone branch, then fails non-fatally at gh.
+    assert.equal(result.pushed, false);
+    assert.equal(result.prCreated, false);
+    assert.equal(result.prUrl, undefined);
+    const remoteHeads = git(repo, "ls-remote", "--heads", bare);
+    assert.match(remoteHeads, /refs\/heads\/milestone\/M001/);
+    assert.doesNotMatch(remoteHeads, /refs\/heads\/main/);
+  } finally {
+    cleanup();
+  }
+});
+
+test("nothing-to-commit short-circuits all publication", () => {
+  const { repo, bare, cleanup } = makeRepoWithBareRemote();
+  try {
+    const result = publishMilestone({
+      ...makeRequest(repo, { autoPush: true, autoPr: false }),
+      nothingToCommit: true,
+    });
+    assert.deepEqual(result, { pushed: false, prCreated: false });
+    const remoteHeads = git(repo, "ls-remote", "--heads", bare);
+    assert.equal(remoteHeads.trim(), "");
+  } finally {
+    cleanup();
+  }
+});
+
+test("missing remote makes publication a silent no-op", () => {
+  const { repo, cleanup } = makeRepoWithBareRemote();
+  try {
+    git(repo, "remote", "remove", "origin");
+    const result = publishMilestone(makeRequest(repo, { autoPush: true, autoPr: true }));
+    assert.deepEqual(result, { pushed: false, prCreated: false });
+  } finally {
+    cleanup();
+  }
+});
+
+test("publication disabled returns the empty result without touching git", () => {
+  const { repo, cleanup } = makeRepoWithBareRemote();
+  try {
+    const result = publishMilestone(makeRequest(repo, NO_PUBLISH_PREFS));
+    assert.deepEqual(result, { pushed: false, prCreated: false });
+  } finally {
+    cleanup();
+  }
+});

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

@@ -0,0 +1,47 @@
+// Project/App: gsd-pi
+// File Purpose: Tests for process-level pull request policy.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  buildPullRequestEvidence,
+  createDraftPullRequestFromEvidence,
+} from "../pull-request-process.js";
+
+test("buildPullRequestEvidence omits AI credit by policy", () => {
+  const evidence = buildPullRequestEvidence({
+    milestoneId: "M001",
+    milestoneTitle: "Git process",
+    aiAssisted: true,
+  });
+
+  assert.equal(evidence.title, "feat: Git process");
+  assert.ok(!evidence.body.includes("## AI Assistance Disclosure"));
+  assert.ok(!evidence.body.includes("AI assistance"));
+});
+
+test("createDraftPullRequestFromEvidence forwards exact evidence and branch options", () => {
+  const calls: unknown[][] = [];
+  const url = createDraftPullRequestFromEvidence(
+    "/repo",
+    "M001",
+    { title: "feat: Git process", body: "body" },
+    { head: "milestone/M001", base: "main" },
+    {
+      createDraftPR: (basePath, milestoneId, title, body, opts) => {
+        calls.push([basePath, milestoneId, title, body, opts]);
+        return "https://github.example/pr/1";
+      },
+    },
+  );
+
+  assert.equal(url, "https://github.example/pr/1");
+  assert.deepEqual(calls, [[
+    "/repo",
+    "M001",
+    "feat: Git process",
+    "body",
+    { head: "milestone/M001", base: "main" },
+  ]]);
+});

package/src/resources/extensions/gsd/tests/recovery-classification-illegal-transition.test.ts

@@ -0,0 +1,30 @@
+// GSD — recovery-classification: illegal-transition kind (ADR-030)
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { classifyFailure } from "../recovery-classification.ts";
+import { IllegalPhaseTransitionError } from "../state-transition-matrix.ts";
+
+test("classifyFailure recognizes IllegalPhaseTransitionError by class and escalates", () => {
+  const classification = classifyFailure({
+    error: new IllegalPhaseTransitionError("executing", "complete"),
+    unitType: "execute-task",
+    unitId: "T-1",
+  });
+
+  assert.equal(classification.failureKind, "illegal-transition");
+  assert.equal(classification.action, "escalate");
+  assert.equal(classification.exitReason, "illegal-transition");
+  assert.match(classification.reason, /Illegal phase transition/);
+});
+
+test("classifyFailure routes an explicit illegal-transition failureKind to the same case", () => {
+  const classification = classifyFailure({
+    error: new Error("derived edge rejected"),
+    failureKind: "illegal-transition",
+  });
+
+  assert.equal(classification.failureKind, "illegal-transition");
+  assert.equal(classification.action, "escalate");
+});