gsd-pi 2.41.0-dev.0acbce9 → 2.41.0-dev.3557dc4

package/src/resources/extensions/gsd/service-tier.ts

@@ -0,0 +1,171 @@
+/**
+ * Service Tier — gating, status formatting, icon resolution, and
+ * the /gsd fast command handler.
+ *
+ * Service tiers (priority/flex) are an OpenAI feature that only applies
+ * to gpt-5.4 variants. This module centralizes the model-gating logic
+ * so that icons, preferences, and the before_provider_request hook all
+ * use a single source of truth.
+ */
+
+import type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
+
+import { existsSync, readFileSync } from "node:fs";
+import { saveFile } from "./files.js";
+import {
+  getGlobalGSDPreferencesPath,
+  loadEffectiveGSDPreferences,
+  loadGlobalGSDPreferences,
+} from "./preferences.js";
+import { ensurePreferencesFile, serializePreferencesToFrontmatter } from "./commands-prefs-wizard.js";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export type ServiceTierSetting = "priority" | "flex" | undefined;
+
+// ─── Gating ──────────────────────────────────────────────────────────────────
+
+/**
+ * Returns true when the given model ID supports OpenAI service tiers.
+ * Currently only gpt-5.4 variants qualify.
+ */
+export function supportsServiceTier(modelId: string): boolean {
+  if (!modelId) return false;
+  // Strip provider prefix if present (e.g. "openai/gpt-5.4" → "gpt-5.4")
+  const bare = modelId.includes("/") ? modelId.split("/").pop()! : modelId;
+  return bare.startsWith("gpt-5.4");
+}
+
+// ─── Status Formatting ───────────────────────────────────────────────────────
+
+/**
+ * Human-readable description of the current service tier setting.
+ */
+export function formatServiceTierStatus(tier: ServiceTierSetting): string {
+  if (!tier) {
+    return [
+      "Service tier: disabled",
+      "",
+      "Usage:",
+      "  /gsd fast on     Set to priority (2x cost, faster)",
+      "  /gsd fast flex   Set to flex (0.5x cost, slower)",
+      "  /gsd fast off    Disable service tier",
+      "",
+      "Only affects gpt-5.4 models.",
+    ].join("\n");
+  }
+
+  const label = tier === "priority" ? "priority (2x cost, faster)" : "flex (0.5x cost, slower)";
+  return [
+    `Service tier: ${label}`,
+    "",
+    "Usage:",
+    "  /gsd fast on     Set to priority (2x cost, faster)",
+    "  /gsd fast flex   Set to flex (0.5x cost, slower)",
+    "  /gsd fast off    Disable service tier",
+    "",
+    "Only affects gpt-5.4 models.",
+  ].join("\n");
+}
+
+// ─── Icon Resolution ─────────────────────────────────────────────────────────
+
+/**
+ * Returns the appropriate icon for the active service tier and model.
+ * Returns empty string when the tier is inactive or the model doesn't
+ * support service tiers.
+ */
+export function resolveServiceTierIcon(tier: ServiceTierSetting, modelId: string): string {
+  if (!tier || !supportsServiceTier(modelId)) return "";
+  return tier === "priority" ? "⚡" : "💰";
+}
+
+// ─── Preference Read ─────────────────────────────────────────────────────────
+
+/**
+ * Read the effective service_tier setting from preferences.
+ */
+export function getEffectiveServiceTier(): ServiceTierSetting {
+  const prefs = loadEffectiveGSDPreferences()?.preferences;
+  const raw = prefs?.service_tier;
+  if (raw === "priority" || raw === "flex") return raw;
+  return undefined;
+}
+
+// ─── Preference Write ────────────────────────────────────────────────────────
+
+function extractBodyAfterFrontmatter(content: string): string | null {
+  const start = content.startsWith("---\n") ? 4 : content.startsWith("---\r\n") ? 5 : -1;
+  if (start === -1) return null;
+  const closingIdx = content.indexOf("\n---", start);
+  if (closingIdx === -1) return null;
+  const after = content.slice(closingIdx + 4);
+  return after.trim() ? after : null;
+}
+
+async function writeGlobalServiceTier(
+  ctx: ExtensionCommandContext,
+  tier: ServiceTierSetting,
+): Promise<void> {
+  const path = getGlobalGSDPreferencesPath();
+  await ensurePreferencesFile(path, ctx, "global");
+
+  const existing = loadGlobalGSDPreferences();
+  const prefs: Record<string, unknown> = existing?.preferences ? { ...existing.preferences } : {};
+  prefs.version = prefs.version || 1;
+
+  if (tier) {
+    prefs.service_tier = tier;
+  } else {
+    delete prefs.service_tier;
+  }
+
+  const frontmatter = serializePreferencesToFrontmatter(prefs);
+  let body = "\n# GSD Skill Preferences\n\nSee `~/.gsd/agent/extensions/gsd/docs/preferences-reference.md` for full field documentation and examples.\n";
+  if (existsSync(path)) {
+    const preserved = extractBodyAfterFrontmatter(readFileSync(path, "utf-8"));
+    if (preserved) body = preserved;
+  }
+
+  await saveFile(path, `---\n${frontmatter}---${body}`);
+  await ctx.waitForIdle();
+  await ctx.reload();
+}
+
+// ─── Command Handler ─────────────────────────────────────────────────────────
+
+/**
+ * Handle `/gsd fast [on|off|flex|status]`.
+ */
+export async function handleFast(args: string, ctx: ExtensionCommandContext): Promise<void> {
+  const trimmed = args.trim().toLowerCase();
+
+  if (!trimmed || trimmed === "status") {
+    const tier = getEffectiveServiceTier();
+    ctx.ui.notify(formatServiceTierStatus(tier), "info");
+    return;
+  }
+
+  if (trimmed === "on") {
+    await writeGlobalServiceTier(ctx, "priority");
+    ctx.ui.notify("Service tier set to priority (2x cost, faster responses). Only affects gpt-5.4 models.", "info");
+    return;
+  }
+
+  if (trimmed === "off") {
+    await writeGlobalServiceTier(ctx, undefined);
+    ctx.ui.notify("Service tier disabled.", "info");
+    return;
+  }
+
+  if (trimmed === "flex") {
+    await writeGlobalServiceTier(ctx, "flex");
+    ctx.ui.notify("Service tier set to flex (0.5x cost, slower responses). Only affects gpt-5.4 models.", "info");
+    return;
+  }
+
+  ctx.ui.notify(
+    "Usage: /gsd fast [on|off|flex|status]\n\n  on    Priority tier (2x cost, faster)\n  off   Disable service tier\n  flex  Flex tier (0.5x cost, slower)\n  status Show current setting",
+    "warning",
+  );
+}

package/src/resources/extensions/gsd/structured-data-formatter.ts

@@ -25,6 +25,7 @@ interface DecisionInput {
   choice: string;
   rationale: string;
   revisable: string;
+  made_by?: string;
 }
 
 interface RequirementInput {
@@ -61,6 +62,7 @@ export function formatDecisionCompact(decision: DecisionInput): string {
     decision.choice,
     decision.rationale,
     decision.revisable,
+    decision.made_by ?? 'agent',
   ].join(" | ");
 }
 
@@ -70,7 +72,7 @@ export function formatDecisionsCompact(decisions: DecisionInput[]): string {
     return "# Decisions (compact)\n(none)";
   }
 
-  const header = "# Decisions (compact)\nFields: id | when | scope | decision | choice | rationale | revisable";
+  const header = "# Decisions (compact)\nFields: id | when | scope | decision | choice | rationale | revisable | made_by";
   const lines = decisions.map(formatDecisionCompact);
   return `${header}\n\n${lines.join("\n")}`;
 }

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

@@ -4,5 +4,5 @@
      To reverse a decision, add a new row that supersedes it.
      Read this file at the start of any planning or research phase. -->
 
-| # | When | Scope | Decision | Choice | Rationale | Revisable? |
-|---|------|-------|----------|--------|-----------|------------|
+| # | When | Scope | Decision | Choice | Rationale | Revisable? | Made By |
+|---|------|-------|----------|--------|-----------|------------|---------|

package/src/resources/extensions/gsd/tests/auto-loop.test.ts

@@ -337,7 +337,7 @@ function makeMockDeps(
     pruneQueueOrder: () => {},
     isInAutoWorktree: () => false,
     shouldUseWorktreeIsolation: () => false,
-    mergeMilestoneToMain: () => ({ pushed: false }),
+    mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
     teardownAutoWorktree: () => {},
     createAutoWorktree: () => "/tmp/wt",
     captureIntegrationBranch: () => {},
@@ -416,6 +416,7 @@ function makeMockDeps(
     getSessionFile: () => "/tmp/session.json",
     rebuildState: async () => {},
     resolveModelId: (id: string, models: any[]) => models.find((m: any) => m.id === id),
+    emitJournalEvent: () => {},
   };
 
   const merged = { ...baseDeps, ...overrides, callLog };
@@ -2122,7 +2123,7 @@ test("autoLoop stops when worktree has no project files for execute-task (#1833)
     "should stop auto-mode when worktree has no project files",
   );
   const healthNotification = notifications.find(
-    (n) => n.includes("Worktree health check failed") && n.includes("no package.json or src/"),
+    (n) => n.includes("Worktree health check failed") && n.includes("no recognized project files"),
   );
   assert.ok(
     healthNotification,

package/src/resources/extensions/gsd/tests/auto-recovery.test.ts

@@ -386,6 +386,91 @@ test("verifyExpectedArtifact plan-slice fails for plan with no tasks (#699)", ()
   }
 });
 
+// ─── verifyExpectedArtifact: heading-style plan tasks (#1691) ─────────────
+
+test("verifyExpectedArtifact accepts plan-slice with heading-style tasks (### T01 --)", () => {
+  const base = makeTmpBase();
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "### T01 -- Implement feature",
+      "",
+      "Feature description.",
+      "",
+      "### T02 -- Write tests",
+      "",
+      "Test description.",
+    ].join("\n"));
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan");
+    writeFileSync(join(tasksDir, "T02-PLAN.md"), "# T02 Plan");
+    assert.strictEqual(
+      verifyExpectedArtifact("plan-slice", "M001/S01", base),
+      true,
+      "Heading-style plan with task entries should be treated as completed artifact",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact accepts plan-slice with colon-style heading tasks (### T01:)", () => {
+  const base = makeTmpBase();
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "### T01: Implement feature",
+      "",
+      "Feature description.",
+    ].join("\n"));
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan");
+    assert.strictEqual(
+      verifyExpectedArtifact("plan-slice", "M001/S01", base),
+      true,
+      "Colon heading-style plan should be treated as completed artifact",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact execute-task passes for heading-style plan entry (#1691)", () => {
+  const base = makeTmpBase();
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "### T01 -- Implement feature",
+      "",
+      "Feature description.",
+    ].join("\n"));
+    writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# T01 Summary\n\nDone.");
+    assert.strictEqual(
+      verifyExpectedArtifact("execute-task", "M001/S01/T01", base),
+      true,
+      "execute-task should pass for heading-style plan entry when summary exists",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
 // ─── selfHealRuntimeRecords — worktree base path (#769) ──────────────────
 
 test("selfHealRuntimeRecords clears stale dispatched records (#769)", async () => {

package/src/resources/extensions/gsd/tests/auto-worktree-milestone-merge.test.ts

@@ -569,6 +569,208 @@ async function main(): Promise<void> {
       assertTrue(existsSync(join(repo, "landed.ts")), "landed.ts present on main");
     }
 
+    // ─── Test 14: Stale branch ref — worktree HEAD ahead of branch (#1846) ─
+    console.log("\n=== stale branch ref — fast-forward before squash merge (#1846) ===");
+    {
+      const repo = freshRepo();
+      const wtPath = createAutoWorktree(repo, "M140");
+
+      // Add a first slice normally — this advances both the branch ref and HEAD
+      addSliceToMilestone(repo, wtPath, "M140", "S01", "Initial work", [
+        { file: "initial.ts", content: "export const initial = true;\n", message: "add initial" },
+      ]);
+
+      // Now simulate the bug: detach HEAD in the worktree, then make commits
+      // that advance HEAD but leave the milestone/M140 branch ref behind.
+      const branchRefBefore = run("git rev-parse milestone/M140", wtPath);
+      run("git checkout --detach HEAD", wtPath);
+
+      // Add multiple commits on the detached HEAD (simulates agent work)
+      writeFileSync(join(wtPath, "feature-a.ts"), "export const featureA = true;\n");
+      run("git add .", wtPath);
+      run('git commit -m "add feature-a"', wtPath);
+
+      writeFileSync(join(wtPath, "feature-b.ts"), "export const featureB = true;\n");
+      run("git add .", wtPath);
+      run('git commit -m "add feature-b"', wtPath);
+
+      writeFileSync(join(wtPath, "feature-c.ts"), "export const featureC = true;\n");
+      run("git add .", wtPath);
+      run('git commit -m "add feature-c"', wtPath);
+
+      // Verify: branch ref is stale, HEAD is ahead
+      const branchRefAfter = run("git rev-parse milestone/M140", wtPath);
+      const worktreeHead = run("git rev-parse HEAD", wtPath);
+      assertEq(branchRefBefore, branchRefAfter, "branch ref unchanged (stale)");
+      assertTrue(worktreeHead !== branchRefAfter, "worktree HEAD ahead of branch ref");
+
+      const roadmap = makeRoadmap("M140", "Stale ref milestone", [
+        { id: "S01", title: "Initial work" },
+      ]);
+
+      // The fix should fast-forward the branch ref to worktree HEAD before
+      // squash-merging, so ALL commits are captured.
+      let threw = false;
+      let errMsg = "";
+      try {
+        const result = mergeMilestoneToMain(repo, "M140", roadmap);
+        assertTrue(result.commitMessage.includes("feat(M140)"), "merge commit created");
+      } catch (err) {
+        threw = true;
+        errMsg = err instanceof Error ? err.message : String(err);
+      }
+      assertTrue(!threw, `should not throw with stale branch ref (got: ${errMsg})`);
+
+      // ALL files from detached HEAD commits must be on main — not just
+      // the ones from the stale branch ref
+      assertTrue(existsSync(join(repo, "initial.ts")), "initial.ts on main");
+      assertTrue(existsSync(join(repo, "feature-a.ts")), "feature-a.ts on main (#1846)");
+      assertTrue(existsSync(join(repo, "feature-b.ts")), "feature-b.ts on main (#1846)");
+      assertTrue(existsSync(join(repo, "feature-c.ts")), "feature-c.ts on main (#1846)");
+    }
+
+    // ─── Test 15: Diverged worktree HEAD — throws instead of losing data (#1846) ─
+    console.log("\n=== diverged worktree HEAD — throws on divergence (#1846) ===");
+    {
+      const repo = freshRepo();
+      const wtPath = createAutoWorktree(repo, "M150");
+
+      addSliceToMilestone(repo, wtPath, "M150", "S01", "Base work", [
+        { file: "base.ts", content: "export const base = true;\n", message: "add base" },
+      ]);
+
+      run("git checkout --detach HEAD", wtPath);
+      writeFileSync(join(wtPath, "detached-work.ts"), "export const detached = true;\n");
+      run("git add .", wtPath);
+      run('git commit -m "detached work"', wtPath);
+
+      run("git checkout milestone/M150", repo);
+      writeFileSync(join(repo, "diverged-work.ts"), "export const diverged = true;\n");
+      run("git add .", repo);
+      run('git commit -m "diverged work on branch"', repo);
+      run("git checkout main", repo);
+
+      process.chdir(wtPath);
+
+      const roadmap = makeRoadmap("M150", "Diverged milestone", [
+        { id: "S01", title: "Base work" },
+      ]);
+
+      let threw = false;
+      let errMsg = "";
+      try {
+        mergeMilestoneToMain(repo, "M150", roadmap);
+      } catch (err) {
+        threw = true;
+        errMsg = err instanceof Error ? err.message : String(err);
+      }
+      assertTrue(threw, "throws when worktree HEAD diverged from branch ref (#1846)");
+      assertTrue(errMsg.includes("diverged"), "error message mentions divergence (#1846)");
+
+      const branches = run("git branch", repo);
+      assertTrue(branches.includes("milestone/M150"), "milestone branch preserved on divergence (#1846)");
+    }
+
+    // ─── Test 16: #1853 Bug 1 — SQUASH_MSG cleaned up after squash-merge ──
+    console.log("\n=== #1853 bug 1: SQUASH_MSG cleaned up after successful squash-merge ===");
+    {
+      const repo = freshRepo();
+      const wtPath = createAutoWorktree(repo, "M160");
+
+      addSliceToMilestone(repo, wtPath, "M160", "S01", "SQUASH_MSG cleanup test", [
+        { file: "squash-cleanup.ts", content: "export const cleanup = true;\n", message: "add squash-cleanup" },
+      ]);
+
+      const roadmap = makeRoadmap("M160", "SQUASH_MSG cleanup", [
+        { id: "S01", title: "SQUASH_MSG cleanup test" },
+      ]);
+
+      const squashMsgPath = join(repo, ".git", "SQUASH_MSG");
+      writeFileSync(squashMsgPath, "leftover squash message\n");
+      assertTrue(existsSync(squashMsgPath), "SQUASH_MSG planted before merge");
+
+      const result = mergeMilestoneToMain(repo, "M160", roadmap);
+      assertTrue(result.commitMessage.includes("feat(M160)"), "merge commit created");
+
+      assertTrue(
+        !existsSync(squashMsgPath),
+        "#1853: SQUASH_MSG must not persist after successful squash-merge",
+      );
+    }
+
+    // ─── Test 17: #1853 Bug 2 — uncommitted worktree code survives teardown ──
+    console.log("\n=== #1853 bug 2: uncommitted worktree changes committed before teardown ===");
+    {
+      const repo = freshRepo();
+      const wtPath = createAutoWorktree(repo, "M170");
+
+      addSliceToMilestone(repo, wtPath, "M170", "S01", "Teardown safety test", [
+        { file: "safe-file.ts", content: "export const safe = true;\n", message: "add safe file" },
+      ]);
+
+      writeFileSync(join(wtPath, "uncommitted-agent-code.ts"), "export const lost = true;\n");
+
+      const roadmap = makeRoadmap("M170", "Teardown safety", [
+        { id: "S01", title: "Teardown safety test" },
+      ]);
+
+      const result = mergeMilestoneToMain(repo, "M170", roadmap);
+      assertTrue(result.commitMessage.includes("feat(M170)"), "merge commit created");
+
+      assertTrue(
+        existsSync(join(repo, "uncommitted-agent-code.ts")),
+        "#1853: uncommitted worktree code must survive teardown",
+      );
+    }
+
+    // ─── Test 18: #1906 — codeFilesChanged false when only .gsd/ metadata merged ──
+    console.log("\n=== #1906: codeFilesChanged=false when only .gsd/ metadata merged ===");
+    {
+      const repo = freshRepo();
+      const wtPath = createAutoWorktree(repo, "M180");
+
+      // Only add .gsd/ metadata files — no actual code
+      mkdirSync(join(wtPath, ".gsd", "milestones", "M180"), { recursive: true });
+      writeFileSync(
+        join(wtPath, ".gsd", "milestones", "M180", "SUMMARY.md"),
+        "# M180 Summary\n\nThis milestone was planned but not implemented.\n",
+      );
+      run("git add .", wtPath);
+      run('git commit -m "chore: add milestone summary"', wtPath);
+
+      const roadmap = makeRoadmap("M180", "Metadata-only milestone", []);
+
+      const result = mergeMilestoneToMain(repo, "M180", roadmap);
+      assertEq(
+        result.codeFilesChanged,
+        false,
+        "#1906: codeFilesChanged must be false when only .gsd/ files were merged",
+      );
+    }
+
+    // ─── Test 19: #1906 — codeFilesChanged true when real code is merged ──
+    console.log("\n=== #1906: codeFilesChanged=true when real code is merged ===");
+    {
+      const repo = freshRepo();
+      const wtPath = createAutoWorktree(repo, "M190");
+
+      addSliceToMilestone(repo, wtPath, "M190", "S01", "Real code", [
+        { file: "real-code.ts", content: "export const real = true;\n", message: "add real code" },
+      ]);
+
+      const roadmap = makeRoadmap("M190", "Code milestone", [
+        { id: "S01", title: "Real code" },
+      ]);
+
+      const result = mergeMilestoneToMain(repo, "M190", roadmap);
+      assertEq(
+        result.codeFilesChanged,
+        true,
+        "#1906: codeFilesChanged must be true when real code files were merged",
+      );
+      assertTrue(existsSync(join(repo, "real-code.ts")), "real-code.ts merged to main");
+    }
+
   } finally {
     process.chdir(savedCwd);
     for (const d of tempDirs) {

package/src/resources/extensions/gsd/tests/context-store.test.ts

@@ -51,17 +51,17 @@ console.log('\n=== context-store: query all active decisions ===');
   insertDecision({
     id: 'D001', when_context: 'M001/S01', scope: 'architecture',
     decision: 'use SQLite', choice: 'node:sqlite', rationale: 'built-in',
-    revisable: 'yes', superseded_by: 'D003', // superseded!
+    revisable: 'yes', made_by: 'agent', superseded_by: 'D003', // superseded!
   });
   insertDecision({
     id: 'D002', when_context: 'M001/S01', scope: 'architecture',
     decision: 'use WAL mode', choice: 'WAL', rationale: 'concurrent reads',
-    revisable: 'no', superseded_by: null,
+    revisable: 'no', made_by: 'agent', superseded_by: null,
   });
   insertDecision({
     id: 'D003', when_context: 'M002/S01', scope: 'performance',
     decision: 'use better-sqlite3', choice: 'better-sqlite3', rationale: 'faster',
-    revisable: 'yes', superseded_by: null,
+    revisable: 'yes', made_by: 'agent', superseded_by: null,
   });
 
   const all = queryDecisions();
@@ -81,11 +81,13 @@ console.log('\n=== context-store: query decisions by milestone ===');
   insertDecision({
     id: 'D001', when_context: 'M001/S01', scope: 'architecture',
     decision: 'decision A', choice: 'A', rationale: 'r', revisable: 'yes',
+    made_by: 'agent',
     superseded_by: null,
   });
   insertDecision({
     id: 'D002', when_context: 'M002/S02', scope: 'architecture',
     decision: 'decision B', choice: 'B', rationale: 'r', revisable: 'yes',
+    made_by: 'agent',
     superseded_by: null,
   });
 
@@ -107,11 +109,13 @@ console.log('\n=== context-store: query decisions by scope ===');
   insertDecision({
     id: 'D001', when_context: 'M001/S01', scope: 'architecture',
     decision: 'decision A', choice: 'A', rationale: 'r', revisable: 'yes',
+    made_by: 'agent',
     superseded_by: null,
   });
   insertDecision({
     id: 'D002', when_context: 'M001/S01', scope: 'performance',
     decision: 'decision B', choice: 'B', rationale: 'r', revisable: 'yes',
+    made_by: 'agent',
     superseded_by: null,
   });
 
@@ -248,12 +252,12 @@ console.log('\n=== context-store: formatDecisionsForPrompt ===');
     {
       seq: 1, id: 'D001', when_context: 'M001/S01', scope: 'architecture',
       decision: 'use SQLite', choice: 'node:sqlite', rationale: 'built-in',
-      revisable: 'yes', superseded_by: null,
+      revisable: 'yes', made_by: 'agent', superseded_by: null,
     },
     {
       seq: 2, id: 'D002', when_context: 'M001/S02', scope: 'performance',
       decision: 'use WAL', choice: 'WAL', rationale: 'concurrent',
-      revisable: 'no', superseded_by: null,
+      revisable: 'no', made_by: 'human', superseded_by: null,
     },
   ]);
 
@@ -323,6 +327,7 @@ console.log('\n=== context-store: sub-5ms query timing ===');
       choice: `choice ${i}`,
       rationale: `rationale ${i}`,
       revisable: i % 3 === 0 ? 'no' : 'yes',
+      made_by: 'agent',
       superseded_by: null,
     });
   }

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

@@ -59,6 +59,7 @@ const SAMPLE_DECISIONS: Decision[] = [
     choice: 'better-sqlite3',
     rationale: 'Sync API',
     revisable: 'No',
+    made_by: 'collaborative',
     superseded_by: null,
   },
   {
@@ -70,6 +71,7 @@ const SAMPLE_DECISIONS: Decision[] = [
     choice: '.gsd/gsd.db',
     rationale: 'Derived state',
     revisable: 'No',
+    made_by: 'agent',
     superseded_by: null,
   },
   {
@@ -81,6 +83,7 @@ const SAMPLE_DECISIONS: Decision[] = [
     choice: 'node:sqlite fallback',
     rationale: 'Zero deps',
     revisable: 'Yes',
+    made_by: 'human',
     superseded_by: null,
   },
 ];
@@ -166,6 +169,7 @@ console.log('\n── generateDecisionsMd round-trip ──');
     assertEq(rt.choice, orig.choice, `decision ${orig.id} choice round-trips`);
     assertEq(rt.rationale, orig.rationale, `decision ${orig.id} rationale round-trips`);
     assertEq(rt.revisable, orig.revisable, `decision ${orig.id} revisable round-trips`);
+    assertEq(rt.made_by, orig.made_by, `decision ${orig.id} made_by round-trips`);
   }
 }
 
@@ -177,6 +181,7 @@ console.log('\n── generateDecisionsMd format ──');
   assertTrue(md.includes('<!-- Append-only'), 'contains HTML comment block');
   assertTrue(md.includes('| # | When | Scope'), 'contains table header');
   assertTrue(md.includes('|---|------|-------'), 'contains separator row');
+  assertTrue(md.includes('| Made By |'), 'contains Made By column header');
 }
 
 console.log('\n── generateDecisionsMd empty input ──');
@@ -200,6 +205,7 @@ console.log('\n── generateDecisionsMd pipe escaping ──');
     choice: 'A',
     rationale: 'Better',
     revisable: 'No',
+    made_by: 'agent',
     superseded_by: null,
   };
   const md = generateDecisionsMd([withPipe]);
@@ -291,6 +297,7 @@ console.log('\n── nextDecisionId ──');
     choice: 'test choice',
     rationale: 'test',
     revisable: 'No',
+    made_by: 'agent',
     superseded_by: null,
   });
   upsertDecision({
@@ -301,6 +308,7 @@ console.log('\n── nextDecisionId ──');
     choice: 'test choice',
     rationale: 'test',
     revisable: 'No',
+    made_by: 'agent',
     superseded_by: null,
   });
 
@@ -520,6 +528,7 @@ console.log('\n── Full DB round-trip: decisions ──');
       choice: d.choice,
       rationale: d.rationale,
       revisable: d.revisable,
+      made_by: d.made_by,
       superseded_by: d.superseded_by,
     });
   }
@@ -536,6 +545,7 @@ console.log('\n── Full DB round-trip: decisions ──');
     choice: row['choice'] as string,
     rationale: row['rationale'] as string,
     revisable: row['revisable'] as string,
+    made_by: (row['made_by'] as string as import('../types.js').DecisionMadeBy) ?? 'agent',
     superseded_by: (row['superseded_by'] as string) ?? null,
   }));