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

package/dist/resources/extensions/gsd/bootstrap/db-tools.js

@@ -2,18 +2,65 @@ import { Type } from "@sinclair/typebox";
 import { findMilestoneIds, nextMilestoneId, claimReservedId, getReservedMilestoneIds } from "../guided-flow.js";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { ensureDbOpen } from "./dynamic-tools.js";
-export function registerDbTools(pi) {
+/**
+ * Register an alias tool that shares the same execute function as its canonical counterpart.
+ * The alias description and promptGuidelines direct the LLM to prefer the canonical name.
+ */
+function registerAlias(pi, toolDef, aliasName, canonicalName) {
     pi.registerTool({
-        name: "gsd_save_decision",
+        ...toolDef,
+        name: aliasName,
+        description: toolDef.description + ` (alias for ${canonicalName} — prefer the canonical name)`,
+        promptGuidelines: [`Alias for ${canonicalName} — prefer the canonical name.`],
+    });
+}
+export function registerDbTools(pi) {
+    // ─── gsd_decision_save (formerly gsd_save_decision) ─────────────────────
+    const decisionSaveExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const dbAvailable = await ensureDbOpen();
+        if (!dbAvailable) {
+            return {
+                content: [{ type: "text", text: "Error: GSD database is not available. Cannot save decision." }],
+                details: { operation: "save_decision", error: "db_unavailable" },
+            };
+        }
+        try {
+            const { saveDecisionToDb } = await import("../db-writer.js");
+            const { id } = await saveDecisionToDb({
+                scope: params.scope,
+                decision: params.decision,
+                choice: params.choice,
+                rationale: params.rationale,
+                revisable: params.revisable,
+                when_context: params.when_context,
+                made_by: params.made_by,
+            }, process.cwd());
+            return {
+                content: [{ type: "text", text: `Saved decision ${id}` }],
+                details: { operation: "save_decision", id },
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`gsd-db: gsd_decision_save tool failed: ${msg}\n`);
+            return {
+                content: [{ type: "text", text: `Error saving decision: ${msg}` }],
+                details: { operation: "save_decision", error: msg },
+            };
+        }
+    };
+    const decisionSaveTool = {
+        name: "gsd_decision_save",
         label: "Save Decision",
         description: "Record a project decision to the GSD database and regenerate DECISIONS.md. " +
             "Decision IDs are auto-assigned — never provide an ID manually.",
         promptSnippet: "Record a project decision to the GSD database (auto-assigns ID, regenerates DECISIONS.md)",
         promptGuidelines: [
-            "Use gsd_save_decision when recording an architectural, pattern, library, or observability decision.",
+            "Use gsd_decision_save when recording an architectural, pattern, library, or observability decision.",
             "Decision IDs are auto-assigned (D001, D002, ...) — never guess or provide an ID.",
-            "All fields except revisable and when_context are required.",
+            "All fields except revisable, when_context, and made_by are required.",
             "The tool writes to the DB and regenerates .gsd/DECISIONS.md automatically.",
+            "Set made_by to 'human' when the user explicitly directed the decision, 'agent' when the LLM chose autonomously (default), or 'collaborative' when it was discussed and agreed together.",
         ],
         parameters: Type.Object({
             scope: Type.String({ description: "Scope of the decision (e.g. 'architecture', 'library', 'observability')" }),
@@ -22,48 +69,71 @@ export function registerDbTools(pi) {
             rationale: Type.String({ description: "Why this choice was made" }),
             revisable: Type.Optional(Type.String({ description: "Whether this can be revisited (default: 'Yes')" })),
             when_context: Type.Optional(Type.String({ description: "When/context for the decision (e.g. milestone ID)" })),
+            made_by: Type.Optional(Type.Union([
+                Type.Literal("human"),
+                Type.Literal("agent"),
+                Type.Literal("collaborative"),
+            ], { description: "Who made this decision: 'human' (user directed), 'agent' (LLM decided autonomously), or 'collaborative' (discussed and agreed). Default: 'agent'" })),
         }),
-        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            const dbAvailable = await ensureDbOpen();
-            if (!dbAvailable) {
-                return {
-                    content: [{ type: "text", text: "Error: GSD database is not available. Cannot save decision." }],
-                    details: { operation: "save_decision", error: "db_unavailable" },
-                };
-            }
-            try {
-                const { saveDecisionToDb } = await import("../db-writer.js");
-                const { id } = await saveDecisionToDb({
-                    scope: params.scope,
-                    decision: params.decision,
-                    choice: params.choice,
-                    rationale: params.rationale,
-                    revisable: params.revisable,
-                    when_context: params.when_context,
-                }, process.cwd());
-                return {
-                    content: [{ type: "text", text: `Saved decision ${id}` }],
-                    details: { operation: "save_decision", id },
-                };
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                process.stderr.write(`gsd-db: gsd_save_decision tool failed: ${msg}\n`);
+        execute: decisionSaveExecute,
+    };
+    pi.registerTool(decisionSaveTool);
+    registerAlias(pi, decisionSaveTool, "gsd_save_decision", "gsd_decision_save");
+    // ─── gsd_requirement_update (formerly gsd_update_requirement) ───────────
+    const requirementUpdateExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const dbAvailable = await ensureDbOpen();
+        if (!dbAvailable) {
+            return {
+                content: [{ type: "text", text: "Error: GSD database is not available. Cannot update requirement." }],
+                details: { operation: "update_requirement", id: params.id, error: "db_unavailable" },
+            };
+        }
+        try {
+            const db = await import("../gsd-db.js");
+            const existing = db.getRequirementById(params.id);
+            if (!existing) {
                 return {
-                    content: [{ type: "text", text: `Error saving decision: ${msg}` }],
-                    details: { operation: "save_decision", error: msg },
+                    content: [{ type: "text", text: `Error: Requirement ${params.id} not found.` }],
+                    details: { operation: "update_requirement", id: params.id, error: "not_found" },
                 };
             }
-        },
-    });
-    pi.registerTool({
-        name: "gsd_update_requirement",
+            const { updateRequirementInDb } = await import("../db-writer.js");
+            const updates = {};
+            if (params.status !== undefined)
+                updates.status = params.status;
+            if (params.validation !== undefined)
+                updates.validation = params.validation;
+            if (params.notes !== undefined)
+                updates.notes = params.notes;
+            if (params.description !== undefined)
+                updates.description = params.description;
+            if (params.primary_owner !== undefined)
+                updates.primary_owner = params.primary_owner;
+            if (params.supporting_slices !== undefined)
+                updates.supporting_slices = params.supporting_slices;
+            await updateRequirementInDb(params.id, updates, process.cwd());
+            return {
+                content: [{ type: "text", text: `Updated requirement ${params.id}` }],
+                details: { operation: "update_requirement", id: params.id },
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`gsd-db: gsd_requirement_update tool failed: ${msg}\n`);
+            return {
+                content: [{ type: "text", text: `Error updating requirement: ${msg}` }],
+                details: { operation: "update_requirement", id: params.id, error: msg },
+            };
+        }
+    };
+    const requirementUpdateTool = {
+        name: "gsd_requirement_update",
         label: "Update Requirement",
         description: "Update an existing requirement in the GSD database and regenerate REQUIREMENTS.md. " +
             "Provide the requirement ID (e.g. R001) and any fields to update.",
         promptSnippet: "Update an existing GSD requirement by ID (regenerates REQUIREMENTS.md)",
         promptGuidelines: [
-            "Use gsd_update_requirement to change status, validation, notes, or other fields on an existing requirement.",
+            "Use gsd_requirement_update to change status, validation, notes, or other fields on an existing requirement.",
             "The id parameter is required — it must be an existing RXXX identifier.",
             "All other fields are optional — only provided fields are updated.",
             "The tool verifies the requirement exists before updating.",
@@ -77,61 +147,68 @@ export function registerDbTools(pi) {
             primary_owner: Type.Optional(Type.String({ description: "Primary owning slice" })),
             supporting_slices: Type.Optional(Type.String({ description: "Supporting slices" })),
         }),
-        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            const dbAvailable = await ensureDbOpen();
-            if (!dbAvailable) {
-                return {
-                    content: [{ type: "text", text: "Error: GSD database is not available. Cannot update requirement." }],
-                    details: { operation: "update_requirement", id: params.id, error: "db_unavailable" },
-                };
+        execute: requirementUpdateExecute,
+    };
+    pi.registerTool(requirementUpdateTool);
+    registerAlias(pi, requirementUpdateTool, "gsd_update_requirement", "gsd_requirement_update");
+    // ─── gsd_summary_save (formerly gsd_save_summary) ──────────────────────
+    const summarySaveExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const dbAvailable = await ensureDbOpen();
+        if (!dbAvailable) {
+            return {
+                content: [{ type: "text", text: "Error: GSD database is not available. Cannot save artifact." }],
+                details: { operation: "save_summary", error: "db_unavailable" },
+            };
+        }
+        const validTypes = ["SUMMARY", "RESEARCH", "CONTEXT", "ASSESSMENT"];
+        if (!validTypes.includes(params.artifact_type)) {
+            return {
+                content: [{ type: "text", text: `Error: Invalid artifact_type "${params.artifact_type}". Must be one of: ${validTypes.join(", ")}` }],
+                details: { operation: "save_summary", error: "invalid_artifact_type" },
+            };
+        }
+        try {
+            let relativePath;
+            if (params.task_id && params.slice_id) {
+                relativePath = `milestones/${params.milestone_id}/slices/${params.slice_id}/tasks/${params.task_id}-${params.artifact_type}.md`;
             }
-            try {
-                const db = await import("../gsd-db.js");
-                const existing = db.getRequirementById(params.id);
-                if (!existing) {
-                    return {
-                        content: [{ type: "text", text: `Error: Requirement ${params.id} not found.` }],
-                        details: { operation: "update_requirement", id: params.id, error: "not_found" },
-                    };
-                }
-                const { updateRequirementInDb } = await import("../db-writer.js");
-                const updates = {};
-                if (params.status !== undefined)
-                    updates.status = params.status;
-                if (params.validation !== undefined)
-                    updates.validation = params.validation;
-                if (params.notes !== undefined)
-                    updates.notes = params.notes;
-                if (params.description !== undefined)
-                    updates.description = params.description;
-                if (params.primary_owner !== undefined)
-                    updates.primary_owner = params.primary_owner;
-                if (params.supporting_slices !== undefined)
-                    updates.supporting_slices = params.supporting_slices;
-                await updateRequirementInDb(params.id, updates, process.cwd());
-                return {
-                    content: [{ type: "text", text: `Updated requirement ${params.id}` }],
-                    details: { operation: "update_requirement", id: params.id },
-                };
+            else if (params.slice_id) {
+                relativePath = `milestones/${params.milestone_id}/slices/${params.slice_id}/${params.slice_id}-${params.artifact_type}.md`;
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                process.stderr.write(`gsd-db: gsd_update_requirement tool failed: ${msg}\n`);
-                return {
-                    content: [{ type: "text", text: `Error updating requirement: ${msg}` }],
-                    details: { operation: "update_requirement", id: params.id, error: msg },
-                };
+            else {
+                relativePath = `milestones/${params.milestone_id}/${params.milestone_id}-${params.artifact_type}.md`;
             }
-        },
-    });
-    pi.registerTool({
-        name: "gsd_save_summary",
+            const { saveArtifactToDb } = await import("../db-writer.js");
+            await saveArtifactToDb({
+                path: relativePath,
+                artifact_type: params.artifact_type,
+                content: params.content,
+                milestone_id: params.milestone_id,
+                slice_id: params.slice_id,
+                task_id: params.task_id,
+            }, process.cwd());
+            return {
+                content: [{ type: "text", text: `Saved ${params.artifact_type} artifact to ${relativePath}` }],
+                details: { operation: "save_summary", path: relativePath, artifact_type: params.artifact_type },
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`gsd-db: gsd_summary_save tool failed: ${msg}\n`);
+            return {
+                content: [{ type: "text", text: `Error saving artifact: ${msg}` }],
+                details: { operation: "save_summary", error: msg },
+            };
+        }
+    };
+    const summarySaveTool = {
+        name: "gsd_summary_save",
         label: "Save Summary",
         description: "Save a summary, research, context, or assessment artifact to the GSD database and write it to disk. " +
             "Computes the file path from milestone/slice/task IDs automatically.",
         promptSnippet: "Save a GSD artifact (summary/research/context/assessment) to DB and disk",
         promptGuidelines: [
-            "Use gsd_save_summary to persist structured artifacts (SUMMARY, RESEARCH, CONTEXT, ASSESSMENT).",
+            "Use gsd_summary_save to persist structured artifacts (SUMMARY, RESEARCH, CONTEXT, ASSESSMENT).",
             "milestone_id is required. slice_id and task_id are optional — they determine the file path.",
             "The tool computes the relative path automatically: milestones/M001/M001-SUMMARY.md, milestones/M001/slices/S01/S01-SUMMARY.md, etc.",
             "artifact_type must be one of: SUMMARY, RESEARCH, CONTEXT, ASSESSMENT.",
@@ -143,98 +220,56 @@ export function registerDbTools(pi) {
             artifact_type: Type.String({ description: "One of: SUMMARY, RESEARCH, CONTEXT, ASSESSMENT" }),
             content: Type.String({ description: "The full markdown content of the artifact" }),
         }),
-        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            const dbAvailable = await ensureDbOpen();
-            if (!dbAvailable) {
-                return {
-                    content: [{ type: "text", text: "Error: GSD database is not available. Cannot save artifact." }],
-                    details: { operation: "save_summary", error: "db_unavailable" },
-                };
-            }
-            const validTypes = ["SUMMARY", "RESEARCH", "CONTEXT", "ASSESSMENT"];
-            if (!validTypes.includes(params.artifact_type)) {
-                return {
-                    content: [{ type: "text", text: `Error: Invalid artifact_type "${params.artifact_type}". Must be one of: ${validTypes.join(", ")}` }],
-                    details: { operation: "save_summary", error: "invalid_artifact_type" },
-                };
-            }
-            try {
-                let relativePath;
-                if (params.task_id && params.slice_id) {
-                    relativePath = `milestones/${params.milestone_id}/slices/${params.slice_id}/tasks/${params.task_id}-${params.artifact_type}.md`;
-                }
-                else if (params.slice_id) {
-                    relativePath = `milestones/${params.milestone_id}/slices/${params.slice_id}/${params.slice_id}-${params.artifact_type}.md`;
-                }
-                else {
-                    relativePath = `milestones/${params.milestone_id}/${params.milestone_id}-${params.artifact_type}.md`;
-                }
-                const { saveArtifactToDb } = await import("../db-writer.js");
-                await saveArtifactToDb({
-                    path: relativePath,
-                    artifact_type: params.artifact_type,
-                    content: params.content,
-                    milestone_id: params.milestone_id,
-                    slice_id: params.slice_id,
-                    task_id: params.task_id,
-                }, process.cwd());
-                return {
-                    content: [{ type: "text", text: `Saved ${params.artifact_type} artifact to ${relativePath}` }],
-                    details: { operation: "save_summary", path: relativePath, artifact_type: params.artifact_type },
-                };
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                process.stderr.write(`gsd-db: gsd_save_summary tool failed: ${msg}\n`);
+        execute: summarySaveExecute,
+    };
+    pi.registerTool(summarySaveTool);
+    registerAlias(pi, summarySaveTool, "gsd_save_summary", "gsd_summary_save");
+    // ─── gsd_milestone_generate_id (formerly gsd_generate_milestone_id) ────
+    const milestoneGenerateIdExecute = async (_toolCallId, _params, _signal, _onUpdate, _ctx) => {
+        try {
+            // Claim a reserved ID if the guided-flow already previewed one to the user.
+            // This guarantees the ID shown in the UI matches the one materialised on disk.
+            const reserved = claimReservedId();
+            if (reserved) {
                 return {
-                    content: [{ type: "text", text: `Error saving artifact: ${msg}` }],
-                    details: { operation: "save_summary", error: msg },
+                    content: [{ type: "text", text: reserved }],
+                    details: { operation: "generate_milestone_id", id: reserved, source: "reserved" },
                 };
             }
-        },
-    });
-    pi.registerTool({
-        name: "gsd_generate_milestone_id",
+            const basePath = process.cwd();
+            const existingIds = findMilestoneIds(basePath);
+            const uniqueEnabled = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
+            const allIds = [...new Set([...existingIds, ...getReservedMilestoneIds()])];
+            const newId = nextMilestoneId(allIds, uniqueEnabled);
+            return {
+                content: [{ type: "text", text: newId }],
+                details: { operation: "generate_milestone_id", id: newId, existingCount: existingIds.length, uniqueEnabled },
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: "text", text: `Error generating milestone ID: ${msg}` }],
+                details: { operation: "generate_milestone_id", error: msg },
+            };
+        }
+    };
+    const milestoneGenerateIdTool = {
+        name: "gsd_milestone_generate_id",
         label: "Generate Milestone ID",
         description: "Generate the next milestone ID for a new GSD milestone. " +
             "Scans existing milestones on disk and respects the unique_milestone_ids preference. " +
             "Always use this tool when creating a new milestone — never invent milestone IDs manually.",
         promptSnippet: "Generate a valid milestone ID (respects unique_milestone_ids preference)",
         promptGuidelines: [
-            "ALWAYS call gsd_generate_milestone_id before creating a new milestone directory or writing milestone files.",
+            "ALWAYS call gsd_milestone_generate_id before creating a new milestone directory or writing milestone files.",
             "Never invent or hardcode milestone IDs like M001, M002 — always use this tool.",
             "Call it once per milestone you need to create. For multi-milestone projects, call it once for each milestone in sequence.",
             "The tool returns the correct format based on project preferences (e.g. M001 or M001-r5jzab).",
         ],
         parameters: Type.Object({}),
-        async execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
-            try {
-                // Claim a reserved ID if the guided-flow already previewed one to the user.
-                // This guarantees the ID shown in the UI matches the one materialised on disk.
-                const reserved = claimReservedId();
-                if (reserved) {
-                    return {
-                        content: [{ type: "text", text: reserved }],
-                        details: { operation: "generate_milestone_id", id: reserved, source: "reserved" },
-                    };
-                }
-                const basePath = process.cwd();
-                const existingIds = findMilestoneIds(basePath);
-                const uniqueEnabled = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
-                const allIds = [...new Set([...existingIds, ...getReservedMilestoneIds()])];
-                const newId = nextMilestoneId(allIds, uniqueEnabled);
-                return {
-                    content: [{ type: "text", text: newId }],
-                    details: { operation: "generate_milestone_id", id: newId, existingCount: existingIds.length, uniqueEnabled },
-                };
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return {
-                    content: [{ type: "text", text: `Error generating milestone ID: ${msg}` }],
-                    details: { operation: "generate_milestone_id", error: msg },
-                };
-            }
-        },
-    });
+        execute: milestoneGenerateIdExecute,
+    };
+    pi.registerTool(milestoneGenerateIdTool);
+    registerAlias(pi, milestoneGenerateIdTool, "gsd_generate_milestone_id", "gsd_milestone_generate_id");
 }

package/dist/resources/extensions/gsd/bootstrap/journal-tools.js

@@ -0,0 +1,62 @@
+import { Type } from "@sinclair/typebox";
+import { queryJournal } from "../journal.js";
+export function registerJournalTools(pi) {
+    pi.registerTool({
+        name: "gsd_journal_query",
+        label: "Query Journal",
+        description: "Query the structured event journal for auto-mode iterations. " +
+            "Returns matching journal entries filtered by flow ID, unit ID, rule name, event type, or time range.",
+        promptSnippet: "Query the GSD event journal with filters (flowId, unitId, rule, eventType, time range, limit)",
+        promptGuidelines: [
+            "Filter by flowId to trace all events from a single auto-mode iteration.",
+            "Filter by unitId to reconstruct the causal chain for a specific milestone/slice/task.",
+            "Use limit to control context size — default is 100 entries.",
+        ],
+        parameters: Type.Object({
+            flowId: Type.Optional(Type.String({ description: "Filter by flow ID (UUID grouping one iteration)" })),
+            unitId: Type.Optional(Type.String({ description: "Filter by unit ID (e.g. M001/S01/T01) from event data" })),
+            rule: Type.Optional(Type.String({ description: "Filter by rule name from the unified registry" })),
+            eventType: Type.Optional(Type.String({ description: "Filter by event type (e.g. dispatch-match, unit-start)" })),
+            after: Type.Optional(Type.String({ description: "ISO-8601 lower bound (inclusive)" })),
+            before: Type.Optional(Type.String({ description: "ISO-8601 upper bound (inclusive)" })),
+            limit: Type.Optional(Type.Number({ description: "Maximum entries to return (default: 100)", default: 100 })),
+        }),
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            try {
+                const filters = {};
+                if (params.flowId !== undefined)
+                    filters.flowId = params.flowId;
+                if (params.unitId !== undefined)
+                    filters.unitId = params.unitId;
+                if (params.rule !== undefined)
+                    filters.rule = params.rule;
+                if (params.eventType !== undefined)
+                    filters.eventType = params.eventType;
+                if (params.after !== undefined)
+                    filters.after = params.after;
+                if (params.before !== undefined)
+                    filters.before = params.before;
+                const entries = queryJournal(process.cwd(), filters);
+                const limited = entries.slice(0, params.limit ?? 100);
+                if (limited.length === 0) {
+                    return {
+                        content: [{ type: "text", text: "No matching journal entries found." }],
+                        details: { operation: "journal_query", count: 0 },
+                    };
+                }
+                return {
+                    content: [{ type: "text", text: JSON.stringify(limited, null, 2) }],
+                    details: { operation: "journal_query", count: limited.length },
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                process.stderr.write(`gsd-journal: gsd_journal_query tool failed: ${msg}\n`);
+                return {
+                    content: [{ type: "text", text: `Error querying journal: ${msg}` }],
+                    details: { operation: "journal_query", error: msg },
+                };
+            }
+        },
+    });
+}

package/dist/resources/extensions/gsd/bootstrap/register-extension.js

@@ -3,6 +3,7 @@ import { registerExitCommand } from "../exit-command.js";
 import { registerWorktreeCommand } from "../worktree-command.js";
 import { registerDbTools } from "./db-tools.js";
 import { registerDynamicTools } from "./dynamic-tools.js";
+import { registerJournalTools } from "./journal-tools.js";
 import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
 function installEpipeGuard() {
@@ -33,6 +34,7 @@ export function registerGsdExtension(pi) {
     });
     registerDynamicTools(pi);
     registerDbTools(pi);
+    registerJournalTools(pi);
     registerShortcuts(pi);
     registerHooks(pi);
 }

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -179,4 +179,20 @@ export function registerHooks(pi) {
     pi.on("tool_execution_end", async (event) => {
         markToolEnd(event.toolCallId);
     });
+    pi.on("before_provider_request", async (event) => {
+        if (!isAutoActive())
+            return;
+        const modelId = event.model?.id;
+        if (!modelId)
+            return;
+        const { getEffectiveServiceTier, supportsServiceTier } = await import("../service-tier.js");
+        const tier = getEffectiveServiceTier();
+        if (!tier || !supportsServiceTier(modelId))
+            return;
+        const payload = event.payload;
+        if (!payload || typeof payload !== "object")
+            return;
+        payload.service_tier = tier;
+        return payload;
+    });
 }

package/dist/resources/extensions/gsd/commands/catalog.js

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { loadRegistry } from "../workflow-templates.js";
 const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
-export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|queue|quick|discuss|capture|triage|dispatch|history|undo|rate|skip|export|cleanup|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|inspect|extensions|update";
+export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|queue|quick|discuss|capture|triage|dispatch|history|undo|rate|skip|export|cleanup|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|inspect|extensions|update|fast";
 export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "help", desc: "Categorized command reference with descriptions" },
     { cmd: "next", desc: "Explicit step mode (same as /gsd)" },
@@ -52,6 +52,7 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "start", desc: "Start a workflow template (bugfix, spike, feature, etc.)" },
     { cmd: "templates", desc: "List available workflow templates" },
     { cmd: "extensions", desc: "Manage extensions (list, enable, disable, info)" },
+    { cmd: "fast", desc: "Toggle OpenAI service tier (on/off/flex/status)" },
 ];
 const NESTED_COMPLETIONS = {
     auto: [
@@ -163,6 +164,12 @@ const NESTED_COMPLETIONS = {
         { cmd: "disable", desc: "Disable an extension" },
         { cmd: "info", desc: "Show extension details" },
     ],
+    fast: [
+        { cmd: "on", desc: "Priority tier (2x cost, faster)" },
+        { cmd: "off", desc: "Disable service tier" },
+        { cmd: "flex", desc: "Flex tier (0.5x cost, slower)" },
+        { cmd: "status", desc: "Show current service tier setting" },
+    ],
     doctor: [
         { cmd: "fix", desc: "Auto-fix detected issues" },
         { cmd: "heal", desc: "AI-driven deep healing" },

package/dist/resources/extensions/gsd/commands/handlers/core.js

@@ -48,6 +48,7 @@ export function showHelp(ctx) {
         "  /gsd keys           API key manager  [list|add|remove|test|rotate|doctor]",
         "  /gsd hooks          Show post-unit hook configuration",
         "  /gsd extensions     Manage extensions  [list|enable|disable|info]",
+        "  /gsd fast           Toggle OpenAI service tier  [on|off|flex|status]",
         "",
         "MAINTENANCE",
         "  /gsd doctor         Diagnose and repair .gsd/ state  [audit|fix|heal] [scope]",

package/dist/resources/extensions/gsd/commands/handlers/ops.js

@@ -169,6 +169,11 @@ Examples:
         await handleUpdate(ctx);
         return true;
     }
+    if (trimmed === "fast" || trimmed.startsWith("fast ")) {
+        const { handleFast } = await import("../../service-tier.js");
+        await handleFast(trimmed.replace(/^fast\s*/, "").trim(), ctx);
+        return true;
+    }
     if (trimmed === "extensions" || trimmed.startsWith("extensions ")) {
         const { handleExtensions } = await import("../../commands-extensions.js");
         await handleExtensions(trimmed.replace(/^extensions\s*/, "").trim(), ctx);

package/dist/resources/extensions/gsd/context-store.js

@@ -39,6 +39,7 @@ export function queryDecisions(opts) {
             choice: row['choice'],
             rationale: row['rationale'],
             revisable: row['revisable'],
+            made_by: row['made_by'] ?? 'agent',
             superseded_by: null,
         }));
     }
@@ -99,9 +100,9 @@ export function queryRequirements(opts) {
 export function formatDecisionsForPrompt(decisions) {
     if (decisions.length === 0)
         return '';
-    const header = '| # | When | Scope | Decision | Choice | Rationale | Revisable? |';
-    const separator = '|---|------|-------|----------|--------|-----------|------------|';
-    const rows = decisions.map(d => `| ${d.id} | ${d.when_context} | ${d.scope} | ${d.decision} | ${d.choice} | ${d.rationale} | ${d.revisable} |`);
+    const header = '| # | When | Scope | Decision | Choice | Rationale | Revisable? | Made By |';
+    const separator = '|---|------|-------|----------|--------|-----------|------------|---------|';
+    const rows = decisions.map(d => `| ${d.id} | ${d.when_context} | ${d.scope} | ${d.decision} | ${d.choice} | ${d.rationale} | ${d.revisable} | ${d.made_by ?? 'agent'} |`);
     return [header, separator, ...rows].join('\n');
 }
 /**

package/dist/resources/extensions/gsd/db-writer.js

@@ -30,8 +30,8 @@ export function generateDecisionsMd(decisions) {
     lines.push('     To reverse a decision, add a new row that supersedes it.');
     lines.push('     Read this file at the start of any planning or research phase. -->');
     lines.push('');
-    lines.push('| # | When | Scope | Decision | Choice | Rationale | Revisable? |');
-    lines.push('|---|------|-------|----------|--------|-----------|------------|');
+    lines.push('| # | When | Scope | Decision | Choice | Rationale | Revisable? | Made By |');
+    lines.push('|---|------|-------|----------|--------|-----------|------------|---------|');
     for (const d of decisions) {
         // Escape pipe characters within cell values to preserve table structure
         const cells = [
@@ -42,6 +42,7 @@ export function generateDecisionsMd(decisions) {
             d.choice,
             d.rationale,
             d.revisable,
+            d.made_by ?? 'agent',
         ].map(cell => (cell ?? '').replace(/\|/g, '\\|'));
         lines.push(`| ${cells.join(' | ')} |`);
     }
@@ -172,6 +173,7 @@ export async function saveDecisionToDb(fields, basePath) {
             choice: fields.choice,
             rationale: fields.rationale,
             revisable: fields.revisable ?? 'Yes',
+            made_by: fields.made_by ?? 'agent',
             superseded_by: null,
         });
         // Fetch all decisions (including superseded for the full register)
@@ -188,6 +190,7 @@ export async function saveDecisionToDb(fields, basePath) {
                 choice: row['choice'],
                 rationale: row['rationale'],
                 revisable: row['revisable'],
+                made_by: row['made_by'] ?? 'agent',
                 superseded_by: row['superseded_by'] ?? null,
             }));
         }