@opengsd/gsd-pi 1.1.1-dev.a5a2de8 → 1.1.1-dev.b2556262

package/src/resources/extensions/gsd/tests/skill-manifest.test.ts

@@ -3,8 +3,8 @@
 // Focused tests for `resolveSkillManifest` and `filterSkillsByManifest`.
 // Covers the wildcard semantics, the newly seeded unit-type entries
 // (complete-milestone, validate-milestone, reassess-roadmap, research-slice,
-// plan-slice, refine-slice, replan-slice, run-uat), and the deliberate
-// wildcard fallback for the execute-task hot path (RFC #4779).
+// plan-slice, refine-slice, replan-slice, run-uat, complete-slice), and the
+// deliberate wildcard fallback for the execute-task hot path (RFC #4779).
 
 import test from "node:test";
 import assert from "node:assert/strict";
@@ -23,6 +23,7 @@ const NEWLY_WIRED_UNIT_TYPES = [
   "refine-slice",
   "replan-slice",
   "run-uat",
+  "complete-slice",
 ] as const;
 
 test("resolveSkillManifest returns null for undefined unit type (wildcard)", () => {
@@ -65,7 +66,7 @@ test("resolveSkillManifest: slice-level manifests include decompose-into-slices"
 });
 
 test("resolveSkillManifest: validation / completion flows include verify-before-complete", () => {
-  for (const unitType of ["complete-milestone", "validate-milestone", "run-uat"] as const) {
+  for (const unitType of ["complete-milestone", "validate-milestone", "run-uat", "complete-slice"] as const) {
     const allowlist = resolveSkillManifest(unitType);
     assert.ok(
       allowlist?.includes("verify-before-complete"),

package/src/resources/extensions/gsd/tests/skipped-validation-db-atomicity.test.ts

@@ -7,6 +7,8 @@ import { tmpdir } from "node:os";
 import { DISPATCH_RULES } from "../auto-dispatch.ts";
 import {
   closeDatabase,
+  getArtifact,
+  getAssessment,
   getLatestAssessmentByScope,
   insertMilestone,
   insertSlice,
@@ -46,6 +48,12 @@ test("skipped validation dispatch persists the validation file and DB assessment
 
     assert.deepEqual(action, { action: "skip" });
     assert.equal(existsSync(join(milestoneDir, "M001-VALIDATION.md")), true);
+    assert.equal(existsSync(join(sliceDir, "S01-ASSESSMENT.md")), true);
+    const artifactPath = "milestones/M001/slices/S01/S01-ASSESSMENT.md";
+    const assessmentPath = `.gsd/${artifactPath}`;
+    assert.equal(getArtifact(artifactPath)?.artifact_type, "ASSESSMENT");
+    assert.equal(getAssessment(assessmentPath)?.scope, "run-uat");
+    assert.equal(getAssessment(assessmentPath)?.status, "pass");
     assert.equal(
       getLatestAssessmentByScope("M001", "milestone-validation")?.status,
       "pass",

package/src/resources/extensions/gsd/tests/source-observations.test.ts

@@ -0,0 +1,275 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  SourceObservationStore,
+  injectSourceContextBlockIntoPayload,
+  observeSourcePath,
+  planDeclaredSourceEntries,
+} from "../source-observations.js";
+import { AutoSession } from "../auto/session.js";
+import { truncateContextResultMessages, truncateResponsesInputResultItems } from "../context-masker.js";
+import type { TaskRow } from "../db-task-slice-rows.js";
+
+function makeTask(overrides: Partial<TaskRow> = {}): TaskRow {
+  return {
+    milestone_id: "M001",
+    slice_id: "S01",
+    id: "T01",
+    title: "Task",
+    status: "pending",
+    one_liner: "",
+    narrative: "",
+    verification_result: "",
+    duration: "",
+    completed_at: null,
+    blocker_discovered: false,
+    deviations: "",
+    known_issues: "",
+    key_files: [],
+    key_decisions: [],
+    full_summary_md: "",
+    description: "",
+    estimate: "",
+    files: [],
+    verify: "",
+    inputs: [],
+    expected_output: [],
+    observability_impact: "",
+    full_plan_md: "",
+    sequence: 1,
+    blocker_source: "",
+    escalation_pending: 0,
+    escalation_awaiting_review: 0,
+    escalation_artifact_path: null,
+    escalation_override_applied_at: null,
+    ...overrides,
+  };
+}
+
+function tempProject(): string {
+  return mkdtempSync(join(tmpdir(), "gsd-source-observations-"));
+}
+
+function beginStore(basePath: string): SourceObservationStore {
+  const store = new SourceObservationStore();
+  store.beginUnit({ unitType: "execute-task", unitId: "M001/S01/T01", startedAt: 123, basePath });
+  return store;
+}
+
+test("plan-declared source entries use task.files and concrete task.inputs, not expectedOutput", () => {
+  const task = makeTask({
+    files: ["src/app.ts"],
+    inputs: ["Current enum shape", "`src/input.ts` - existing input"],
+    expected_output: ["src/generated.ts"],
+  });
+
+  assert.deepEqual(planDeclaredSourceEntries(task), [
+    { path: "src/app.ts", field: "files" },
+    { path: "src/input.ts", field: "inputs" },
+  ]);
+});
+
+test("preloaded plan observations render whole files and unavailable statuses", () => {
+  const basePath = tempProject();
+  mkdirSync(join(basePath, "src"), { recursive: true });
+  writeFileSync(join(basePath, "src", "app.ts"), "export const value = 1;\n");
+  mkdirSync(join(basePath, "src", "directory"), { recursive: true });
+  writeFileSync(join(basePath, "image.png"), Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]));
+
+  const store = beginStore(basePath);
+  store.observePlanTask(makeTask({
+    files: [
+      "src/app.ts",
+      "src/missing.ts",
+      "src/*.ts",
+      "src/directory/",
+      "image.png",
+    ],
+  }));
+
+  const block = store.renderActiveBlock();
+  assert.ok(block);
+  assert.match(block, /## Source Context Block/);
+  assert.match(block, /#### src\/app\.ts/);
+  assert.match(block, /export const value = 1;/);
+  assert.match(block, /src\/missing\.ts: missing/);
+  assert.match(block, /src\/\*\.ts: glob/);
+  assert.match(block, /src\/directory: directory/);
+  assert.match(block, /image\.png: binary\/image/);
+});
+
+test("narrow reads of under-threshold files auto-upgrade to whole-file observations", () => {
+  const basePath = tempProject();
+  mkdirSync(join(basePath, "src"), { recursive: true });
+  writeFileSync(join(basePath, "src", "app.ts"), ["line one", "line two", "line three"].join("\n"));
+
+  const store = beginStore(basePath);
+  store.observeRead({ path: "src/app.ts", offset: 2, limit: 1 });
+
+  const block = store.renderActiveBlock();
+  assert.ok(block);
+  assert.match(block, /line one/);
+  assert.match(block, /line two/);
+  assert.match(block, /line three/);
+});
+
+test("successful file mutations refresh active whole-file observations", () => {
+  const basePath = tempProject();
+  writeFileSync(join(basePath, "app.ts"), "export const value = 'before';\n");
+
+  const store = beginStore(basePath);
+  store.observeRead({ path: "app.ts" });
+
+  assert.match(store.renderActiveBlock() ?? "", /before/);
+
+  writeFileSync(join(basePath, "app.ts"), "export const value = 'after';\n");
+  store.observeMutation({ path: "app.ts" });
+
+  const block = store.renderActiveBlock() ?? "";
+  assert.match(block, /after/);
+  assert.doesNotMatch(block, /before/);
+});
+
+test("successful writes promote missing plan observations to whole files", () => {
+  const basePath = tempProject();
+  const store = beginStore(basePath);
+  store.observePlanTask(makeTask({ files: ["generated.ts"] }));
+
+  assert.match(store.renderActiveBlock() ?? "", /generated\.ts: missing/);
+
+  writeFileSync(join(basePath, "generated.ts"), "export const generated = true;\n");
+  store.observeMutation({ path: "generated.ts" });
+
+  const block = store.renderActiveBlock() ?? "";
+  assert.match(block, /#### generated\.ts/);
+  assert.match(block, /export const generated = true;/);
+  assert.doesNotMatch(block, /generated\.ts: missing/);
+});
+
+test("over-threshold files are explicit unavailable observations", () => {
+  const basePath = tempProject();
+  writeFileSync(join(basePath, "large.txt"), "a".repeat(51 * 1024));
+
+  const observation = observeSourcePath(basePath, "large.txt", "plan");
+
+  assert.equal(observation.status, "over-threshold");
+  assert.match(observation.reason ?? "", /exceeds/);
+});
+
+test("outside-root paths are unavailable and never inlined", () => {
+  const root = tempProject();
+  const basePath = join(root, "project");
+  const outsidePath = join(root, "outside");
+  mkdirSync(basePath, { recursive: true });
+  mkdirSync(outsidePath, { recursive: true });
+  writeFileSync(join(outsidePath, "secret.txt"), "do not inline me\n");
+
+  const absoluteObservation = observeSourcePath(basePath, join(outsidePath, "secret.txt"), "read");
+  const relativeObservation = observeSourcePath(basePath, "../outside/secret.txt", "read");
+
+  assert.equal(absoluteObservation.status, "unresolved selector");
+  assert.equal(relativeObservation.status, "unresolved selector");
+  assert.match(absoluteObservation.reason ?? "", /outside active Unit root/);
+  assert.match(relativeObservation.reason ?? "", /outside active Unit root/);
+  assert.equal(absoluteObservation.text, undefined);
+  assert.equal(relativeObservation.text, undefined);
+});
+
+test("source observations only render for execute-task units", () => {
+  const basePath = tempProject();
+  writeFileSync(join(basePath, "plan.md"), "planning context\n");
+
+  const store = new SourceObservationStore();
+  store.beginUnit({ unitType: "plan-slice", unitId: "M001/S01", startedAt: 123, basePath });
+  store.observeRead({ path: "plan.md" });
+
+  assert.equal(store.renderActiveBlock(), null);
+});
+
+test("source context block injection survives tool-result truncation for messages payloads", () => {
+  const payload = {
+    messages: truncateContextResultMessages([
+      { role: "toolResult", content: [{ type: "text", text: "x".repeat(200) }], toolCallId: "read-1", toolName: "read", isError: false },
+    ] as any, 10),
+  };
+
+  const injected = injectSourceContextBlockIntoPayload(payload, "## Source Context Block\n\nfull source text");
+
+  assert.match((injected.messages as any[])[0].content[0].text, /truncated/);
+  assert.equal((injected.messages as any[])[1].content[0].text, "## Source Context Block\n\nfull source text");
+});
+
+test("source context block injection supports Responses input payloads", () => {
+  const payload = {
+    input: truncateResponsesInputResultItems([
+      { type: "function_call_output", call_id: "read-1", output: "x".repeat(200) },
+    ] as any, 10),
+  };
+
+  const injected = injectSourceContextBlockIntoPayload(payload, "## Source Context Block\n\nfull source text");
+
+  assert.match((injected.input as any[])[0].output, /truncated/);
+  assert.equal((injected.input as any[])[1].content[0].text, "## Source Context Block\n\nfull source text");
+});
+
+test("unit-close degradation removes active whole-file source text", () => {
+  const basePath = tempProject();
+  writeFileSync(join(basePath, "app.ts"), "export const value = 1;");
+  const store = beginStore(basePath);
+  store.observeRead({ path: "app.ts" });
+
+  assert.match(store.renderActiveBlock() ?? "", /export const value = 1/);
+
+  store.degradeUnit({ unitType: "execute-task", unitId: "M001/S01/T01", startedAt: 123 });
+
+  assert.equal(store.renderActiveBlock(), null);
+});
+
+test("AutoSession current-unit clear removes active source observations", () => {
+  const basePath = tempProject();
+  writeFileSync(join(basePath, "app.ts"), "export const value = 1;");
+  const session = new AutoSession();
+  session.basePath = basePath;
+  session.setCurrentUnit({
+    type: "execute-task",
+    id: "M001/S01/T01",
+    startedAt: 123,
+    workspaceRoot: basePath,
+  });
+  session.sourceObservations.observeRead({ path: "app.ts" });
+
+  assert.match(session.sourceObservations.renderActiveBlock() ?? "", /export const value = 1/);
+
+  session.clearCurrentUnit();
+
+  assert.equal(session.sourceObservations.renderActiveBlock(), null);
+});
+
+test("AutoSession clears source observations when switching to non-execute units", () => {
+  const basePath = tempProject();
+  writeFileSync(join(basePath, "app.ts"), "export const value = 1;");
+  const session = new AutoSession();
+  session.basePath = basePath;
+  session.setCurrentUnit({
+    type: "execute-task",
+    id: "M001/S01/T01",
+    startedAt: 123,
+    workspaceRoot: basePath,
+  });
+  session.sourceObservations.observeRead({ path: "app.ts" });
+
+  assert.match(session.sourceObservations.renderActiveBlock() ?? "", /export const value = 1/);
+
+  session.setCurrentUnit({
+    type: "plan-slice",
+    id: "M001/S01",
+    startedAt: 124,
+    workspaceRoot: basePath,
+  });
+
+  assert.equal(session.sourceObservations.renderActiveBlock(), null);
+});

package/src/resources/extensions/gsd/tests/stale-queued-milestone.test.ts

@@ -100,6 +100,7 @@ describe("stale queued milestone selection (#3470)", () => {
     const state = await deriveStateFromDb(base);
 
     assert.equal(state.activeMilestone?.id, "M068", "Queued milestone with draft should become active");
+    assert.equal(state.phase, "needs-discussion", "Queued milestone with draft should resume discussion");
   });
 
   test("queued milestone WITH slices can still be selected as active", async () => {
@@ -144,4 +145,46 @@ describe("stale queued milestone selection (#3470)", () => {
       assert.equal(entry!.status, "pending", `${id} should be pending, not active`);
     }
   });
+
+  test("queued milestone with stale CONTEXT-DRAFT does not block real active milestone", async () => {
+    base = createFixtureBase();
+    openDatabase(":memory:");
+
+    // M068: queued, no slices, has a CONTEXT-DRAFT (abandoned discussion)
+    insertMilestone({ id: "M068", title: "Abandoned Draft", status: "queued" });
+    writeFile(base, "milestones/M068/M068-CONTEXT-DRAFT.md", "# M068: Abandoned Draft\n\nDraft left over from an abandoned session.");
+
+    // M070: real active milestone with execution artifacts
+    insertMilestone({ id: "M070", title: "Real Active", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M070", title: "Slice One", status: "active", risk: "low", depends: [] });
+    insertTask({ id: "T01", sliceId: "S01", milestoneId: "M070", title: "Task One", status: "pending" });
+
+    writeFile(base, "milestones/M070/M070-CONTEXT.md", "# M070: Real Active\n\nThis is the real milestone.");
+    writeFile(base, "milestones/M070/M070-ROADMAP.md", "# M070: Real Active\n\n## Slices\n\n- [ ] **S01: Slice One**");
+    writeFile(base, "milestones/M070/slices/S01/S01-PLAN.md", "# S01: Slice One\n\n## Tasks\n\n- [ ] **T01: Task One**");
+
+    invalidateStateCache();
+    const state = await deriveStateFromDb(base);
+
+    assert.equal(state.activeMilestone?.id, "M070", "Stale draft on M068 must not block real active M070");
+
+    const m068Entry = state.registry.find((e: any) => e.id === "M068");
+    assert.ok(m068Entry, "M068 should still appear in registry");
+    assert.equal(m068Entry!.status, "pending", "M068 with stale draft should be pending, not active");
+  });
+
+  test("queued milestone with CONTEXT-DRAFT becomes active with needs-discussion phase when nothing else is active", async () => {
+    base = createFixtureBase();
+    openDatabase(":memory:");
+
+    // M068: queued, no slices, has a CONTEXT-DRAFT — should resume discussion
+    insertMilestone({ id: "M068", title: "Draft Only", status: "queued" });
+    writeFile(base, "milestones/M068/M068-CONTEXT-DRAFT.md", "# M068: Draft Only\n\nPartial context from first question round.");
+
+    invalidateStateCache();
+    const state = await deriveStateFromDb(base);
+
+    assert.equal(state.activeMilestone?.id, "M068", "Queued milestone with draft should become active when nothing else is");
+    assert.equal(state.phase, "needs-discussion", "Should resume discussion for queued milestone with draft");
+  });
 });

package/src/resources/extensions/gsd/tests/state-reconciliation-drift.test.ts

@@ -152,35 +152,50 @@ test("ADR-017 (#5700): repair failure throws ReconciliationFailedError with shap
   );
 });
 
-test("ADR-017 (#5700): detector failure throws ReconciliationFailedError with shape", async () => {
-  const handler: DriftHandler = {
-    kind: "stale-sketch-flag",
+test("ADR-017 (#5700): a detector failure degrades to a blocker without aborting other handlers", async () => {
+  // A single detector throwing (e.g. a transient file read error) must NOT
+  // abort the whole cycle and hide every later handler's drift. It is collected
+  // as a blocker (so dispatch is still gated) while the remaining detectors run
+  // and their drift is repaired — graceful degradation, not fail-fast.
+  const throwingHandler: DriftHandler = {
+    kind: "stale-render",
     detect: () => {
       throw new Error("simulated detect failure");
     },
     repair: () => {
-      /* detect fails before repair */
+      /* never reached: detect throws */
     },
   };
 
-  await assert.rejects(
-    () =>
-      reconcileBeforeDispatch("/project", {
-        invalidateStateCache: () => {},
-        deriveState: async () => makeState(),
-        registry: [handler],
-      }),
-    (err: unknown) => {
-      assert.ok(err instanceof ReconciliationFailedError, "must be ReconciliationFailedError");
-      assert.equal(err.failures.length, 1);
-      assert.equal(err.failures[0]?.drift.kind, "stale-sketch-flag");
-      assert.ok(err.failures[0]?.cause instanceof Error);
-      assert.equal((err.failures[0]?.cause as Error).message, "simulated detect failure");
-      assert.equal(err.pass, 0);
-      assert.equal(err.detectionFailures.length, 0);
-      assert.equal(err.persistentDrift.length, 0);
-      return true;
+  let repairCount = 0;
+  const workingHandler: DriftHandler = {
+    kind: "stale-sketch-flag",
+    detect: () =>
+      repairCount === 0
+        ? [{ kind: "stale-sketch-flag", mid: "M001", sid: "S02" }]
+        : [],
+    repair: () => {
+      repairCount++;
     },
+  };
+
+  const result = await reconcileBeforeDispatch("/project", {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState(),
+    registry: [throwingHandler, workingHandler],
+  });
+
+  assert.equal(result.ok, true, "cycle must not abort on a single detector failure");
+  // The working handler (registered AFTER the thrower) still detected + repaired.
+  assert.equal(repairCount, 1, "later handler must still run despite earlier detect failure");
+  assert.equal(result.repaired.length, 1);
+  assert.equal(result.repaired[0]?.kind, "stale-sketch-flag");
+  // The detector failure surfaces as a blocker so dispatch is still gated.
+  assert.ok(
+    result.blockers.some(
+      (b) => b.includes("stale-render") && b.includes("simulated detect failure"),
+    ),
+    "detect failure must surface as a blocker",
   );
 });
 
@@ -746,6 +761,46 @@ test("ADR-017 (#5702): missing UAT.md clears stale full_uat_md from DB", async (
   );
 });
 
+test("ADR-017 (#5702): stale-render plan repair works with descriptor-layout milestone dir", async (t) => {
+  // Regression for bugbot finding: repairStaleRenderFromBasePath was passing the
+  // raw dir segment (e.g. M001-DESCRIPTOR) straight to renderPlanCheckboxes, which
+  // queries the DB as getSliceTasks("M001-DESCRIPTOR", …) → empty → throws.
+  // After the fix it calls canonicalizeMilestoneId() first.
+  const base = mkdtempSync(join(tmpdir(), "gsd-adr017-descriptor-"));
+  // Use a descriptor-style directory name (M001-DESCRIPTOR → DB milestone M001)
+  const milestoneDir = "M001-DESCRIPTOR";
+  const sliceDir = join(base, ".gsd", "milestones", milestoneDir, "slices", "S01");
+  mkdirSync(join(sliceDir, "tasks"), { recursive: true });
+  t.after(() => {
+    try { closeDatabase(); } catch { /* noop */ }
+    rmTreeQuiet(base);
+  });
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  clearRendererCaches();
+  // DB uses the canonical ID (M001), directory uses the descriptor name.
+  insertMilestone({ id: "M001", title: "Descriptor Test", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Task One", status: "done" });
+
+  const planPath = join(sliceDir, "S01-PLAN.md");
+  writeFileSync(planPath, makeStalePlanContent("S01", [
+    { id: "T01", title: "Task One", done: false },
+  ]));
+  clearRendererCaches();
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState(),
+  });
+
+  assert.equal(result.ok, true, "reconcile should succeed with descriptor-layout milestone dir");
+  const renderRepaired = result.repaired.find((d) => d.kind === "stale-render");
+  assert.ok(renderRepaired, "stale-render drift should be repaired");
+  const repairedContent = readFileSync(planPath, "utf-8");
+  assert.match(repairedContent, /\[x\][^\n]*T01:/, "T01 checkbox should be checked after repair");
+});
+
 // ─── #5703: stale-worker drift ───────────────────────────────────────────────
 
 const DEAD_PID = 999_999_999; // far above any realistic system PID; process.kill(pid, 0) → ESRCH