gsd-pi 2.79.0-dev.5c910bb05 → 2.79.0-dev.8f814f3af

package/src/resources/extensions/shared/gsd-phase-state.ts

@@ -1,5 +1,5 @@
 /**
- * GSD Phase State — cross-extension coordination
+ * GSD2 Phase State — cross-extension coordination
  * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
  *
  * Lightweight module-level state that GSD auto-mode writes to and the
@@ -7,28 +7,81 @@
  * a module variable is sufficient — no file I/O needed.
  */
 
+import { buildAuditEnvelope, emitUokAuditEvent } from "../gsd/uok/audit.js";
+
 let _active = false;
 let _currentPhase: string | null = null;
 
+export interface GSDPhaseAuditContext {
+	basePath: string;
+	traceId: string;
+	turnId?: string;
+	causedBy?: string;
+}
+
+let _auditContext: GSDPhaseAuditContext | null = null;
+
+function emitPhaseChange(action: string, previousPhase: string | null, nextPhase: string | null): void {
+	if (!_auditContext) return;
+	emitUokAuditEvent(
+		_auditContext.basePath,
+		buildAuditEnvelope({
+			traceId: _auditContext.traceId,
+			turnId: _auditContext.turnId,
+			causedBy: _auditContext.causedBy,
+			category: "orchestration",
+			type: "phase_changed",
+			payload: {
+				action,
+				active: _active,
+				previousPhase,
+				nextPhase,
+			},
+		}),
+	);
+}
+
+export function configureGSDPhaseAudit(context: GSDPhaseAuditContext | null): void {
+	_auditContext = context;
+}
+
 /** Mark GSD auto-mode as active. */
-export function activateGSD(): void {
+export function activateGSD(context?: GSDPhaseAuditContext): void {
+	if (context) _auditContext = context;
+	const previousPhase = _currentPhase;
 	_active = true;
+	emitPhaseChange("activate", previousPhase, _currentPhase);
 }
 
 /** Mark GSD auto-mode as inactive and clear the current phase. */
 export function deactivateGSD(): void {
+	const previousPhase = _currentPhase;
 	_active = false;
 	_currentPhase = null;
+	emitPhaseChange("deactivate", previousPhase, _currentPhase);
+	_auditContext = null;
 }
 
 /** Set the currently dispatched GSD phase (e.g. "plan-milestone"). */
-export function setCurrentPhase(phase: string): void {
+export function setCurrentPhase(phase: string, context?: GSDPhaseAuditContext): boolean {
+	if (context) _auditContext = context;
+	if (!_active) {
+		process.emitWarning(`Ignoring GSD phase "${phase}" while GSD auto-mode is inactive`, {
+			code: "GSD_PHASE_INACTIVE",
+		});
+		return false;
+	}
+	const previousPhase = _currentPhase;
 	_currentPhase = phase;
+	emitPhaseChange("set", previousPhase, _currentPhase);
+	return true;
 }
 
 /** Clear the current phase (unit completed or aborted). */
 export function clearCurrentPhase(): void {
+	const previousPhase = _currentPhase;
 	_currentPhase = null;
+	emitPhaseChange("clear", previousPhase, _currentPhase);
 }
 
 /** Returns true if GSD auto-mode is currently active. */

package/src/resources/extensions/shared/interview-ui.ts

@@ -1,3 +1,4 @@
+// GSD2 — Shared interview round UI widget
 /**
  * Shared interview round UI widget.
  *
@@ -224,12 +225,24 @@ export async function showInterviewRound(
 		let showingExitConfirm = false;
 		let exitCursor = 0; // 0 = keep going (default), 1 = end interview
 		let cachedLines: string[] | undefined;
+		let completed = false;
+		let removeAbortListener: (() => void) | undefined;
+
+		function finish(result: RoundResult) {
+			if (completed) return;
+			completed = true;
+			removeAbortListener?.();
+			done(result);
+		}
 
 		// External cancellation (e.g. remote channel won the race)
 		if (opts.signal) {
-			const onAbort = () => done({ endInterview: false, answers: {} });
+			const onAbort = () => finish({ endInterview: false, answers: {} });
 			if (opts.signal.aborted) { onAbort(); }
-			else { opts.signal.addEventListener("abort", onAbort, { once: true }); }
+			else {
+				opts.signal.addEventListener("abort", onAbort, { once: true });
+				removeAbortListener = () => opts.signal?.removeEventListener("abort", onAbort);
+			}
 		}
 
 		// Editor is created once; editorTheme comes from the design system
@@ -312,7 +325,7 @@ export async function showInterviewRound(
 
 		function submit() {
 			saveEditorToState();
-			done(buildResult());
+			finish(buildResult());
 		}
 
 		function goNextOrSubmit() {
@@ -355,10 +368,10 @@ export async function showInterviewRound(
 				if (matchesKey(data, Key.up) || matchesKey(data, Key.left)) { exitCursor = 0; refresh(); return; }
 				if (matchesKey(data, Key.down) || matchesKey(data, Key.right)) { exitCursor = 1; refresh(); return; }
 				if (data === "1") { showingExitConfirm = false; refresh(); return; }
-				if (data === "2") { done({ endInterview: false, answers: {} }); return; }
+				if (data === "2") { finish({ endInterview: false, answers: {} }); return; }
 				if (matchesKey(data, Key.enter) || matchesKey(data, Key.space)) {
 					if (exitCursor === 0) { showingExitConfirm = false; refresh(); }
-					else { done({ endInterview: false, answers: {} }); }
+					else { finish({ endInterview: false, answers: {} }); }
 					return;
 				}
 				if (matchesKey(data, Key.escape)) { showingExitConfirm = false; refresh(); return; }

package/src/resources/extensions/shared/tests/gsd-phase-state.test.ts

@@ -1,7 +1,13 @@
+// GSD2 Shared Phase State Coordination Tests
+
 import { describe, it, beforeEach } from "node:test";
 import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import {
 	activateGSD,
+	configureGSDPhaseAudit,
 	deactivateGSD,
 	setCurrentPhase,
 	clearCurrentPhase,
@@ -25,12 +31,18 @@ describe("gsd-phase-state", () => {
 	it("tracks the current phase when active", () => {
 		activateGSD();
 		assert.equal(getCurrentPhase(), null);
-		setCurrentPhase("plan-milestone");
+		assert.equal(setCurrentPhase("plan-milestone"), true);
 		assert.equal(getCurrentPhase(), "plan-milestone");
 		clearCurrentPhase();
 		assert.equal(getCurrentPhase(), null);
 	});
 
+	it("rejects phase changes while inactive", () => {
+		assert.equal(setCurrentPhase("plan-milestone"), false);
+		activateGSD();
+		assert.equal(getCurrentPhase(), null);
+	});
+
 	it("returns null phase when inactive even if phase was set", () => {
 		activateGSD();
 		setCurrentPhase("plan-milestone");
@@ -45,4 +57,34 @@ describe("gsd-phase-state", () => {
 		activateGSD();
 		assert.equal(getCurrentPhase(), null);
 	});
+
+	it("deactivation clears the audit context so later events do not carry stale trace data", () => {
+		const basePath = mkdtempSync(join(tmpdir(), "gsd-phase-state-audit-"));
+		try {
+			activateGSD({ basePath, traceId: "stale-trace", causedBy: "test" });
+			setCurrentPhase("plan-milestone");
+			deactivateGSD();
+
+			// Re-activate WITHOUT a context. If deactivate did not clear the
+			// stored context, this setCurrentPhase would emit an audit event
+			// using "stale-trace".
+			activateGSD();
+			setCurrentPhase("execute-task");
+
+			const eventsPath = join(basePath, ".gsd", "audit", "events.jsonl");
+			if (existsSync(eventsPath)) {
+				const contents = readFileSync(eventsPath, "utf-8");
+				assert.equal(
+					contents.includes("stale-trace") &&
+						contents.split("\n").filter((line) => line.includes("stale-trace") && line.includes("execute-task")).length > 0,
+					false,
+					"execute-task phase change must not be emitted under the deactivated trace",
+				);
+			}
+		} finally {
+			configureGSDPhaseAudit(null);
+			deactivateGSD();
+			rmSync(basePath, { recursive: true, force: true });
+		}
+	});
 });

package/src/resources/extensions/shared/tests/interview-notes-loop.test.ts

@@ -139,4 +139,45 @@ describe("interview-ui notes loop regression (#3502)", () => {
 		assert.ok(answer, "answer for q1 should exist");
 		assert.equal(answer.selected, "Web App");
 	});
+
+	it("ignores abort signals after a submitted answer", async () => {
+		const controller = new AbortController();
+		const doneCalls: RoundResult[] = [];
+		let widget: { handleInput(input: string): void } | undefined;
+
+		const resultPromise = showInterviewRound(questions, { signal: controller.signal }, {
+			ui: {
+				custom: (factory: any) => new Promise<RoundResult>((resolve) => {
+					const mockTui = { requestRender: () => {} };
+					const mockTheme = {
+						fg: (_c: string, t: string) => t,
+						bold: (t: string) => t,
+						dim: (t: string) => t,
+						italic: (t: string) => t,
+						strikethrough: (t: string) => t,
+						accent: (t: string) => t,
+						success: (t: string) => t,
+						warning: (t: string) => t,
+						error: (t: string) => t,
+						info: (t: string) => t,
+						muted: (t: string) => t,
+						dimmed: (t: string) => t,
+					};
+					widget = factory(mockTui, mockTheme, {}, (result: RoundResult) => {
+						doneCalls.push(result);
+						resolve(result);
+					});
+				}),
+			},
+		} as any);
+
+		assert.ok(widget, "widget should be created synchronously");
+		widget.handleInput(ENTER);
+		widget.handleInput(ENTER);
+		controller.abort();
+
+		const result = await resultPromise;
+		assert.equal(doneCalls.length, 1, "abort after submit must not emit a second empty result");
+		assert.deepEqual(result.answers.q1, { selected: "Web App", notes: "" });
+	});
 });