gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/src/resources/extensions/gsd/tests/queue-order.test.ts

@@ -1,3 +1,5 @@
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
@@ -9,10 +11,6 @@ import {
   pruneQueueOrder,
   validateQueueOrder,
 } from '../queue-order.ts';
-import { createTestContext } from './test-helpers.ts';
-
-const { assertEq, assertTrue, report } = createTestContext();
-
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
 function createFixtureBase(): string {
@@ -29,176 +27,166 @@ function cleanup(base: string): void {
 // sortByQueueOrder
 // ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n=== sortByQueueOrder ===');
 
+describe('queue-order', () => {
+test('sortByQueueOrder', () => {
 // Null order → default milestoneIdSort
-{
   const result = sortByQueueOrder(['M003', 'M001', 'M002'], null);
-  assertEq(result, ['M001', 'M002', 'M003'], 'null order falls back to numeric sort');
-}
+  assert.deepStrictEqual(result, ['M001', 'M002', 'M003'], 'null order falls back to numeric sort');
+});
 
 // Custom order → exact sequence
-{
+test('test block at line 39', () => {
   const result = sortByQueueOrder(['M001', 'M002', 'M003'], ['M003', 'M001', 'M002']);
-  assertEq(result, ['M003', 'M001', 'M002'], 'custom order produces exact sequence');
-}
+  assert.deepStrictEqual(result, ['M003', 'M001', 'M002'], 'custom order produces exact sequence');
+});
 
 // Custom order with new IDs → appended at end in numeric order
-{
+test('test block at line 45', () => {
   const result = sortByQueueOrder(['M001', 'M002', 'M003', 'M004'], ['M003', 'M001']);
-  assertEq(result, ['M003', 'M001', 'M002', 'M004'], 'new IDs appended in numeric order');
-}
+  assert.deepStrictEqual(result, ['M003', 'M001', 'M002', 'M004'], 'new IDs appended in numeric order');
+});
 
 // Custom order with deleted IDs → silently skipped
-{
+test('test block at line 51', () => {
   const result = sortByQueueOrder(['M001', 'M003'], ['M003', 'M002', 'M001']);
-  assertEq(result, ['M003', 'M001'], 'deleted IDs in order are skipped');
-}
+  assert.deepStrictEqual(result, ['M003', 'M001'], 'deleted IDs in order are skipped');
+});
 
 // Empty custom order → all IDs in numeric order
-{
+test('test block at line 57', () => {
   const result = sortByQueueOrder(['M002', 'M001'], []);
-  assertEq(result, ['M001', 'M002'], 'empty custom order falls back to numeric sort');
-}
+  assert.deepStrictEqual(result, ['M001', 'M002'], 'empty custom order falls back to numeric sort');
+});
 
 // ═══════════════════════════════════════════════════════════════════════════
 // loadQueueOrder / saveQueueOrder
 // ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== loadQueueOrder / saveQueueOrder ===');
-
+test('loadQueueOrder / saveQueueOrder', () => {
 // Load returns null when file doesn't exist
-{
   const base = createFixtureBase();
-  assertEq(loadQueueOrder(base), null, 'returns null when file missing');
+  assert.deepStrictEqual(loadQueueOrder(base), null, 'returns null when file missing');
   cleanup(base);
-}
+});
 
 // Save then load round-trip
-{
+test('test block at line 76', () => {
   const base = createFixtureBase();
   saveQueueOrder(base, ['M003', 'M001', 'M002']);
   const loaded = loadQueueOrder(base);
-  assertEq(loaded, ['M003', 'M001', 'M002'], 'round-trip preserves order');
+  assert.deepStrictEqual(loaded, ['M003', 'M001', 'M002'], 'round-trip preserves order');
 
   // Verify file contains updatedAt
   const raw = JSON.parse(readFileSync(join(base, '.gsd', 'QUEUE-ORDER.json'), 'utf-8'));
-  assertTrue(typeof raw.updatedAt === 'string' && raw.updatedAt.length > 0, 'file contains updatedAt');
+  assert.ok(typeof raw.updatedAt === 'string' && raw.updatedAt.length > 0, 'file contains updatedAt');
 
   cleanup(base);
-}
+});
 
 // Load returns null on corrupt JSON
-{
+test('test block at line 90', () => {
   const base = createFixtureBase();
   writeFileSync(join(base, '.gsd', 'QUEUE-ORDER.json'), 'not json');
-  assertEq(loadQueueOrder(base), null, 'returns null on corrupt JSON');
+  assert.deepStrictEqual(loadQueueOrder(base), null, 'returns null on corrupt JSON');
   cleanup(base);
-}
+});
 
 // Load returns null when order field is not an array
-{
+test('test block at line 98', () => {
   const base = createFixtureBase();
   writeFileSync(join(base, '.gsd', 'QUEUE-ORDER.json'), '{"order": "invalid"}');
-  assertEq(loadQueueOrder(base), null, 'returns null when order is not array');
+  assert.deepStrictEqual(loadQueueOrder(base), null, 'returns null when order is not array');
   cleanup(base);
-}
+});
 
 // ═══════════════════════════════════════════════════════════════════════════
 // pruneQueueOrder
 // ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== pruneQueueOrder ===');
-
+test('pruneQueueOrder', () => {
 // Prune removes invalid IDs
-{
   const base = createFixtureBase();
   saveQueueOrder(base, ['M001', 'M002', 'M003']);
   pruneQueueOrder(base, ['M001', 'M003']);
-  assertEq(loadQueueOrder(base), ['M001', 'M003'], 'prune removes invalid IDs');
+  assert.deepStrictEqual(loadQueueOrder(base), ['M001', 'M003'], 'prune removes invalid IDs');
   cleanup(base);
-}
+});
 
 // Prune no-ops when file doesn't exist
-{
+test('test block at line 121', () => {
   const base = createFixtureBase();
   pruneQueueOrder(base, ['M001']); // should not throw
-  assertTrue(!existsSync(join(base, '.gsd', 'QUEUE-ORDER.json')), 'prune does not create file');
+  assert.ok(!existsSync(join(base, '.gsd', 'QUEUE-ORDER.json')), 'prune does not create file');
   cleanup(base);
-}
+});
 
 // Prune no-ops when all IDs are valid
-{
+test('test block at line 129', () => {
   const base = createFixtureBase();
   saveQueueOrder(base, ['M001', 'M002']);
   pruneQueueOrder(base, ['M001', 'M002', 'M003']);
-  assertEq(loadQueueOrder(base), ['M001', 'M002'], 'prune is no-op when all valid');
+  assert.deepStrictEqual(loadQueueOrder(base), ['M001', 'M002'], 'prune is no-op when all valid');
   cleanup(base);
-}
+});
 
 // ═══════════════════════════════════════════════════════════════════════════
 // validateQueueOrder
 // ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== validateQueueOrder ===');
-
+test('validateQueueOrder', () => {
 // Valid order with no dependencies
-{
   const depsMap = new Map<string, string[]>();
   const result = validateQueueOrder(['M001', 'M002'], depsMap, new Set());
-  assertTrue(result.valid, 'valid when no dependencies');
-  assertEq(result.violations.length, 0, 'no violations');
-  assertEq(result.redundant.length, 0, 'no redundancies');
-}
+  assert.ok(result.valid, 'valid when no dependencies');
+  assert.deepStrictEqual(result.violations.length, 0, 'no violations');
+  assert.deepStrictEqual(result.redundant.length, 0, 'no redundancies');
+});
 
 // Dependency violation: M002 before M001, but M002 depends on M001
-{
+test('test block at line 153', () => {
   const depsMap = new Map<string, string[]>([['M002', ['M001']]]);
   const result = validateQueueOrder(['M002', 'M001'], depsMap, new Set());
-  assertTrue(!result.valid, 'invalid when dep violated');
-  assertEq(result.violations.length, 1, 'one violation');
-  assertEq(result.violations[0].type, 'would_block', 'violation type is would_block');
-  assertEq(result.violations[0].milestone, 'M002', 'violation milestone is M002');
-  assertEq(result.violations[0].dependsOn, 'M001', 'violation dep is M001');
-}
+  assert.ok(!result.valid, 'invalid when dep violated');
+  assert.deepStrictEqual(result.violations.length, 1, 'one violation');
+  assert.deepStrictEqual(result.violations[0].type, 'would_block', 'violation type is would_block');
+  assert.deepStrictEqual(result.violations[0].milestone, 'M002', 'violation milestone is M002');
+  assert.deepStrictEqual(result.violations[0].dependsOn, 'M001', 'violation dep is M001');
+});
 
 // Redundant dependency: M002 depends on M001, M001 comes first in order
-{
+test('test block at line 164', () => {
   const depsMap = new Map<string, string[]>([['M002', ['M001']]]);
   const result = validateQueueOrder(['M001', 'M002'], depsMap, new Set());
-  assertTrue(result.valid, 'valid when dep satisfied by position');
-  assertEq(result.redundant.length, 1, 'one redundancy');
-  assertEq(result.redundant[0].milestone, 'M002', 'redundant milestone is M002');
-}
+  assert.ok(result.valid, 'valid when dep satisfied by position');
+  assert.deepStrictEqual(result.redundant.length, 1, 'one redundancy');
+  assert.deepStrictEqual(result.redundant[0].milestone, 'M002', 'redundant milestone is M002');
+});
 
 // Completed dep is always satisfied
-{
+test('test block at line 173', () => {
   const depsMap = new Map<string, string[]>([['M002', ['M001']]]);
   const result = validateQueueOrder(['M002'], depsMap, new Set(['M001']));
-  assertTrue(result.valid, 'valid when dep is already completed');
-  assertEq(result.violations.length, 0, 'no violations for completed dep');
-}
+  assert.ok(result.valid, 'valid when dep is already completed');
+  assert.deepStrictEqual(result.violations.length, 0, 'no violations for completed dep');
+});
 
 // Missing dependency
-{
+test('test block at line 181', () => {
   const depsMap = new Map<string, string[]>([['M002', ['M099']]]);
   const result = validateQueueOrder(['M001', 'M002'], depsMap, new Set());
-  assertTrue(!result.valid, 'invalid when dep does not exist');
-  assertEq(result.violations[0].type, 'missing_dep', 'violation type is missing_dep');
-}
+  assert.ok(!result.valid, 'invalid when dep does not exist');
+  assert.deepStrictEqual(result.violations[0].type, 'missing_dep', 'violation type is missing_dep');
+});
 
 // Circular dependency
-{
+test('test block at line 189', () => {
   const depsMap = new Map<string, string[]>([
     ['M001', ['M002']],
     ['M002', ['M001']],
   ]);
   const result = validateQueueOrder(['M001', 'M002'], depsMap, new Set());
-  assertTrue(!result.valid, 'invalid on circular dependency');
+  assert.ok(!result.valid, 'invalid on circular dependency');
   const circularViolation = result.violations.find(v => v.type === 'circular');
-  assertTrue(!!circularViolation, 'circular violation detected');
-}
+  assert.ok(!!circularViolation, 'circular violation detected');
+});
 
 // ═══════════════════════════════════════════════════════════════════════════
-
-report();
+});

package/src/resources/extensions/gsd/tests/queue-reorder-e2e.test.ts

@@ -11,6 +11,8 @@
  * 4. A fresh deriveState() call (simulating new session) also works
  */
 
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
@@ -19,10 +21,6 @@ import { deriveState, invalidateStateCache } from '../state.ts';
 import { findMilestoneIds } from '../guided-flow.ts';
 import { saveQueueOrder, loadQueueOrder } from '../queue-order.ts';
 import { parseContextDependsOn } from '../files.ts';
-import { createTestContext } from './test-helpers.ts';
-
-const { assertEq, assertTrue, report } = createTestContext();
-
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
 function createFixtureBase(): string {
@@ -70,8 +68,9 @@ function readContextFile(base: string, mid: string): string {
 // Test: Queue order changes milestone activation
 // ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n=== E2E: queue-order changes active milestone ===');
-{
+
+describe('queue-reorder-e2e', () => {
+test('E2E: queue-order changes active milestone', async () => {
   const base = createFixtureBase();
   try {
     // Setup: M007 complete, M008 and M009 pending (no context, no roadmap)
@@ -84,7 +83,7 @@ console.log('\n=== E2E: queue-order changes active milestone ===');
     // Without custom order: M008 comes first (numeric sort)
     invalidateStateCache();
     const stateBefore = await deriveState(base);
-    assertEq(stateBefore.activeMilestone?.id, 'M008', 'before reorder: M008 is active');
+    assert.deepStrictEqual(stateBefore.activeMilestone?.id, 'M008', 'before reorder: M008 is active');
 
     // Save custom order: M009 before M008
     saveQueueOrder(base, ['M009', 'M008']);
@@ -92,25 +91,23 @@ console.log('\n=== E2E: queue-order changes active milestone ===');
     // With custom order: M009 should be active
     invalidateStateCache();
     const stateAfter = await deriveState(base);
-    assertEq(stateAfter.activeMilestone?.id, 'M009', 'after reorder: M009 is active');
+    assert.deepStrictEqual(stateAfter.activeMilestone?.id, 'M009', 'after reorder: M009 is active');
 
     // findMilestoneIds respects the order
     const ids = findMilestoneIds(base);
     const m008Idx = ids.indexOf('M008');
     const m009Idx = ids.indexOf('M009');
-    assertTrue(m009Idx < m008Idx, 'findMilestoneIds: M009 comes before M008');
+    assert.ok(m009Idx < m008Idx, 'findMilestoneIds: M009 comes before M008');
 
   } finally {
     cleanup(base);
   }
-}
+});
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Test: Reorder + depends_on removal = correct state
 // ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== E2E: reorder with depends_on removal ===');
-{
+test('E2E: reorder with depends_on removal', async () => {
   const base = createFixtureBase();
   try {
     // Setup: M007 complete, M008 depends_on M009, M009 no deps
@@ -121,7 +118,7 @@ console.log('\n=== E2E: reorder with depends_on removal ===');
     // Before: M008 depends on M009, so deriveState skips M008, M009 is active
     invalidateStateCache();
     const stateBefore = await deriveState(base);
-    assertEq(stateBefore.activeMilestone?.id, 'M009', 'before: M009 active (M008 dep-blocked)');
+    assert.deepStrictEqual(stateBefore.activeMilestone?.id, 'M009', 'before: M009 active (M008 dep-blocked)');
 
     // Simulate reorder confirm: save order M009→M008, remove depends_on from M008
     saveQueueOrder(base, ['M009', 'M008']);
@@ -134,29 +131,27 @@ console.log('\n=== E2E: reorder with depends_on removal ===');
     // Verify: depends_on is gone
     const updatedContent = readContextFile(base, 'M008');
     const deps = parseContextDependsOn(updatedContent);
-    assertEq(deps.length, 0, 'depends_on removed from M008-CONTEXT.md');
+    assert.deepStrictEqual(deps.length, 0, 'depends_on removed from M008-CONTEXT.md');
 
     // Verify: deriveState still picks M009 (it's first in queue order)
     invalidateStateCache();
     const stateAfter = await deriveState(base);
-    assertEq(stateAfter.activeMilestone?.id, 'M009', 'after: M009 still active (first in queue)');
+    assert.deepStrictEqual(stateAfter.activeMilestone?.id, 'M009', 'after: M009 still active (first in queue)');
 
     // Verify: M008 is now pending (not dep-blocked)
     const m008Entry = stateAfter.registry.find(m => m.id === 'M008');
-    assertEq(m008Entry?.status, 'pending', 'M008 is pending (not dep-blocked)');
-    assertTrue(!m008Entry?.dependsOn || m008Entry.dependsOn.length === 0, 'M008 has no dependsOn');
+    assert.deepStrictEqual(m008Entry?.status, 'pending', 'M008 is pending (not dep-blocked)');
+    assert.ok(!m008Entry?.dependsOn || m008Entry.dependsOn.length === 0, 'M008 has no dependsOn');
 
   } finally {
     cleanup(base);
   }
-}
+});
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Test: Fresh deriveState (simulating new session) respects queue order
 // ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== E2E: fresh session respects queue order ===');
-{
+test('E2E: fresh session respects queue order', async () => {
   const base = createFixtureBase();
   try {
     writeCompleteMilestone(base, 'M007');
@@ -171,23 +166,21 @@ console.log('\n=== E2E: fresh session respects queue order ===');
 
     // Derive state — should read QUEUE-ORDER.json from disk
     const state = await deriveState(base);
-    assertEq(state.activeMilestone?.id, 'M009', 'fresh session: M009 is active');
+    assert.deepStrictEqual(state.activeMilestone?.id, 'M009', 'fresh session: M009 is active');
 
     // Verify queue order persisted
     const order = loadQueueOrder(base);
-    assertEq(order, ['M009', 'M008'], 'QUEUE-ORDER.json persisted correctly');
+    assert.deepStrictEqual(order, ['M009', 'M008'], 'QUEUE-ORDER.json persisted correctly');
 
   } finally {
     cleanup(base);
   }
-}
+});
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Test: Queue order with newly added milestones
 // ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== E2E: new milestones appended to queue ===');
-{
+test('E2E: new milestones appended to queue', async () => {
   const base = createFixtureBase();
   try {
     writeCompleteMilestone(base, 'M007');
@@ -207,24 +200,22 @@ console.log('\n=== E2E: new milestones appended to queue ===');
     const m009Idx = ids.indexOf('M009');
     const m008Idx = ids.indexOf('M008');
     const m010Idx = ids.indexOf('M010');
-    assertTrue(m009Idx < m008Idx, 'M009 before M008');
-    assertTrue(m008Idx < m010Idx, 'M008 before M010 (new milestone appended)');
+    assert.ok(m009Idx < m008Idx, 'M009 before M008');
+    assert.ok(m008Idx < m010Idx, 'M008 before M010 (new milestone appended)');
 
     // M009 is still active (first non-complete in queue order)
     const state = await deriveState(base);
-    assertEq(state.activeMilestone?.id, 'M009', 'M009 still active after M010 added');
+    assert.deepStrictEqual(state.activeMilestone?.id, 'M009', 'M009 still active after M010 added');
 
   } finally {
     cleanup(base);
   }
-}
+});
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Test: No queue order file = default numeric sort (backward compat)
 // ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== E2E: backward compat without QUEUE-ORDER.json ===');
-{
+test('E2E: backward compat without QUEUE-ORDER.json', async () => {
   const base = createFixtureBase();
   try {
     writeCompleteMilestone(base, 'M007');
@@ -234,22 +225,20 @@ console.log('\n=== E2E: backward compat without QUEUE-ORDER.json ===');
     // No QUEUE-ORDER.json — default numeric sort
     invalidateStateCache();
     const state = await deriveState(base);
-    assertEq(state.activeMilestone?.id, 'M008', 'no queue order: M008 active (numeric)');
+    assert.deepStrictEqual(state.activeMilestone?.id, 'M008', 'no queue order: M008 active (numeric)');
 
     const ids = findMilestoneIds(base);
-    assertTrue(ids.indexOf('M008') < ids.indexOf('M009'), 'default sort: M008 before M009');
+    assert.ok(ids.indexOf('M008') < ids.indexOf('M009'), 'default sort: M008 before M009');
 
   } finally {
     cleanup(base);
   }
-}
+});
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Test: non-milestone directories are filtered out (#1494)
 // ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== E2E: non-milestone directories filtered from findMilestoneIds (#1494) ===');
-{
+test('E2E: non-milestone directories filtered from findMilestoneIds (#1494)', () => {
   const base = createFixtureBase();
   try {
     writeContext(base, 'M001', '', 'First');
@@ -260,22 +249,20 @@ console.log('\n=== E2E: non-milestone directories filtered from findMilestoneIds
 
     invalidateStateCache();
     const ids = findMilestoneIds(base);
-    assertEq(ids.length, 2, 'only M001 and M002 returned');
-    assertTrue(!ids.includes('slices'), 'slices directory excluded');
-    assertTrue(!ids.includes('temp-backup'), 'temp-backup directory excluded');
-    assertTrue(ids.includes('M001'), 'M001 included');
-    assertTrue(ids.includes('M002'), 'M002 included');
+    assert.deepStrictEqual(ids.length, 2, 'only M001 and M002 returned');
+    assert.ok(!ids.includes('slices'), 'slices directory excluded');
+    assert.ok(!ids.includes('temp-backup'), 'temp-backup directory excluded');
+    assert.ok(ids.includes('M001'), 'M001 included');
+    assert.ok(ids.includes('M002'), 'M002 included');
   } finally {
     cleanup(base);
   }
-}
+});
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Test: depends_on inline array format removal
 // ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== E2E: depends_on inline format preserved after partial removal ===');
-{
+test('E2E: depends_on inline format preserved after partial removal', () => {
   const base = createFixtureBase();
   try {
     writeCompleteMilestone(base, 'M007');
@@ -287,7 +274,7 @@ console.log('\n=== E2E: depends_on inline format preserved after partial removal
     // Verify both deps are parsed
     const contentBefore = readContextFile(base, 'M008');
     const depsBefore = parseContextDependsOn(contentBefore);
-    assertEq(depsBefore.length, 2, 'M008 has 2 deps before');
+    assert.deepStrictEqual(depsBefore.length, 2, 'M008 has 2 deps before');
 
     // Simulate removing only M009 dep (keep M010)
     const content = readContextFile(base, 'M008');
@@ -297,12 +284,12 @@ console.log('\n=== E2E: depends_on inline format preserved after partial removal
     // Verify only M010 remains
     const contentAfter = readContextFile(base, 'M008');
     const depsAfter = parseContextDependsOn(contentAfter);
-    assertEq(depsAfter.length, 1, 'M008 has 1 dep after removal');
-    assertEq(depsAfter[0], 'M010', 'remaining dep is M010');
+    assert.deepStrictEqual(depsAfter.length, 1, 'M008 has 1 dep after removal');
+    assert.deepStrictEqual(depsAfter[0], 'M010', 'remaining dep is M010');
 
   } finally {
     cleanup(base);
   }
-}
+});
 
-report();
+});

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

@@ -0,0 +1,100 @@
+/**
+ * Tests that /gsd quick is blocked when auto-mode is active.
+ *
+ * Relates to #2417: /gsd quick freezes terminal when auto-mode is active.
+ * The fix adds an isAutoActive() guard in handleWorkflowCommand before
+ * delegating to handleQuick.
+ */
+
+import { describe, it, mock, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// ─── Structural test: verify the guard exists in source ──────────────────────
+
+describe("/gsd quick auto-mode guard (#2417)", () => {
+  it("handleWorkflowCommand checks isAutoActive() before calling handleQuick", () => {
+    // Read the source file and verify the guard is structurally present
+    const src = readFileSync(
+      join(
+        import.meta.dirname,
+        "..",
+        "commands",
+        "handlers",
+        "workflow.ts",
+      ),
+      "utf-8",
+    );
+
+    // Find the quick command block
+    const quickBlockMatch = src.match(
+      /if\s*\(\s*trimmed\s*===\s*"quick"\s*\|\|\s*trimmed\.startsWith\("quick "\)\s*\)\s*\{([\s\S]*?)\n  \}/,
+    );
+    assert.ok(quickBlockMatch, "quick command block exists in handleWorkflowCommand");
+
+    const quickBlock = quickBlockMatch[1];
+
+    // Verify isAutoActive guard comes BEFORE handleQuick call
+    const guardIndex = quickBlock.indexOf("isAutoActive()");
+    const handleQuickIndex = quickBlock.indexOf("handleQuick(");
+
+    assert.ok(guardIndex !== -1, "isAutoActive() guard exists in quick command block");
+    assert.ok(handleQuickIndex !== -1, "handleQuick() call exists in quick command block");
+    assert.ok(
+      guardIndex < handleQuickIndex,
+      "isAutoActive() guard appears before handleQuick() call",
+    );
+  });
+
+  it("guard shows error message mentioning /gsd stop", () => {
+    const src = readFileSync(
+      join(
+        import.meta.dirname,
+        "..",
+        "commands",
+        "handlers",
+        "workflow.ts",
+      ),
+      "utf-8",
+    );
+
+    // The error message should tell the user to stop auto-mode first
+    assert.ok(
+      src.includes("/gsd quick cannot run while auto-mode is active"),
+      "error message explains that quick cannot run during auto-mode",
+    );
+    assert.ok(
+      src.includes("/gsd stop"),
+      "error message mentions /gsd stop as the resolution",
+    );
+  });
+
+  it("guard returns true (handled) to prevent falling through", () => {
+    const src = readFileSync(
+      join(
+        import.meta.dirname,
+        "..",
+        "commands",
+        "handlers",
+        "workflow.ts",
+      ),
+      "utf-8",
+    );
+
+    // After the isAutoActive() check and notify, there should be a `return true`
+    // before the handleQuick call
+    const quickBlockMatch = src.match(
+      /if\s*\(\s*trimmed\s*===\s*"quick"\s*\|\|\s*trimmed\.startsWith\("quick "\)\s*\)\s*\{([\s\S]*?)\n  \}/,
+    );
+    assert.ok(quickBlockMatch);
+    const quickBlock = quickBlockMatch[1];
+
+    // The guard block should have its own return true before handleQuick
+    const guardBlock = quickBlock.slice(0, quickBlock.indexOf("handleQuick("));
+    assert.ok(
+      guardBlock.includes("return true"),
+      "guard block returns true before handleQuick is reached",
+    );
+  });
+});