gsd-pi 2.17.0 → 2.18.0

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

@@ -0,0 +1,281 @@
+/**
+ * End-to-end integration tests for the Queue Reorder feature.
+ *
+ * Verifies the full chain: QUEUE-ORDER.json + findMilestoneIds() + deriveState()
+ * + depends_on removal from CONTEXT.md files.
+ *
+ * These tests simulate what happens when a user reorders milestones and confirms:
+ * 1. QUEUE-ORDER.json is written with the new order
+ * 2. depends_on is removed from CONTEXT.md frontmatter
+ * 3. deriveState() picks the correct milestone as active
+ * 4. A fresh deriveState() call (simulating new session) also works
+ */
+
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+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 {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-reorder-e2e-'));
+  mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+function writeMilestoneDir(base: string, mid: string): void {
+  mkdirSync(join(base, '.gsd', 'milestones', mid), { recursive: true });
+}
+
+function writeContext(base: string, mid: string, frontmatter: string, body: string = ''): void {
+  const dir = join(base, '.gsd', 'milestones', mid);
+  mkdirSync(dir, { recursive: true });
+  const fm = frontmatter ? `---\n${frontmatter}\n---\n\n` : '';
+  writeFileSync(join(dir, `${mid}-CONTEXT.md`), `${fm}# ${mid}: Test\n\n${body}`);
+}
+
+function writeCompleteMilestone(base: string, mid: string): void {
+  const dir = join(base, '.gsd', 'milestones', mid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${mid}-ROADMAP.md`), `# ${mid}: Complete
+
+**Vision:** Done.
+
+## Slices
+
+- [x] **S01: Done** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+`);
+  writeFileSync(join(dir, `${mid}-SUMMARY.md`), `# ${mid} Summary\n\nComplete.`);
+}
+
+function readContextFile(base: string, mid: string): string {
+  return readFileSync(join(base, '.gsd', 'milestones', mid, `${mid}-CONTEXT.md`), 'utf-8');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Test: Queue order changes milestone activation
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== E2E: queue-order changes active milestone ===');
+{
+  const base = createFixtureBase();
+  try {
+    // Setup: M007 complete, M008 and M009 pending (no context, no roadmap)
+    writeCompleteMilestone(base, 'M007');
+    writeMilestoneDir(base, 'M008');
+    writeContext(base, 'M008', '', 'Multi-Session Parallel Orchestration');
+    writeMilestoneDir(base, 'M009');
+    writeContext(base, 'M009', '', 'Context-Budget Visibility');
+
+    // Without custom order: M008 comes first (numeric sort)
+    invalidateStateCache();
+    const stateBefore = await deriveState(base);
+    assertEq(stateBefore.activeMilestone?.id, 'M008', 'before reorder: M008 is active');
+
+    // Save custom order: M009 before M008
+    saveQueueOrder(base, ['M009', 'M008']);
+
+    // With custom order: M009 should be active
+    invalidateStateCache();
+    const stateAfter = await deriveState(base);
+    assertEq(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');
+
+  } finally {
+    cleanup(base);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Test: Reorder + depends_on removal = correct state
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== E2E: reorder with depends_on removal ===');
+{
+  const base = createFixtureBase();
+  try {
+    // Setup: M007 complete, M008 depends_on M009, M009 no deps
+    writeCompleteMilestone(base, 'M007');
+    writeContext(base, 'M008', 'depends_on: [M009]', 'Multi-Session Parallel');
+    writeContext(base, 'M009', '', 'Context-Budget Visibility');
+
+    // 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)');
+
+    // Simulate reorder confirm: save order M009→M008, remove depends_on from M008
+    saveQueueOrder(base, ['M009', 'M008']);
+
+    // Remove depends_on from M008-CONTEXT.md (simulating what handleQueueReorder does)
+    const contextContent = readContextFile(base, 'M008');
+    const newContent = contextContent.replace(/---\ndepends_on: \[M009\]\n---\n\n/, '');
+    writeFileSync(join(base, '.gsd', 'milestones', 'M008', 'M008-CONTEXT.md'), newContent);
+
+    // 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');
+
+    // 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)');
+
+    // 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');
+
+  } finally {
+    cleanup(base);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Test: Fresh deriveState (simulating new session) respects queue order
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== E2E: fresh session respects queue order ===');
+{
+  const base = createFixtureBase();
+  try {
+    writeCompleteMilestone(base, 'M007');
+    writeContext(base, 'M008', '', 'Parallel Orchestration');
+    writeContext(base, 'M009', '', 'Budget Visibility');
+
+    // Save queue order
+    saveQueueOrder(base, ['M009', 'M008']);
+
+    // Simulate fresh session — invalidate all caches
+    invalidateStateCache();
+
+    // Derive state — should read QUEUE-ORDER.json from disk
+    const state = await deriveState(base);
+    assertEq(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');
+
+  } finally {
+    cleanup(base);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Test: Queue order with newly added milestones
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== E2E: new milestones appended to queue ===');
+{
+  const base = createFixtureBase();
+  try {
+    writeCompleteMilestone(base, 'M007');
+    writeContext(base, 'M008', '', 'Parallel');
+    writeContext(base, 'M009', '', 'Visibility');
+
+    // Custom order only has M009, M008
+    saveQueueOrder(base, ['M009', 'M008']);
+
+    // Add M010 (not in queue order)
+    writeContext(base, 'M010', '', 'New feature');
+
+    invalidateStateCache();
+    const ids = findMilestoneIds(base);
+
+    // M009 first, M008 second, M010 appended at end
+    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)');
+
+    // 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');
+
+  } finally {
+    cleanup(base);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Test: No queue order file = default numeric sort (backward compat)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== E2E: backward compat without QUEUE-ORDER.json ===');
+{
+  const base = createFixtureBase();
+  try {
+    writeCompleteMilestone(base, 'M007');
+    writeContext(base, 'M008', '', 'Parallel');
+    writeContext(base, 'M009', '', 'Visibility');
+
+    // No QUEUE-ORDER.json — default numeric sort
+    invalidateStateCache();
+    const state = await deriveState(base);
+    assertEq(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');
+
+  } finally {
+    cleanup(base);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Test: depends_on inline array format removal
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== E2E: depends_on inline format preserved after partial removal ===');
+{
+  const base = createFixtureBase();
+  try {
+    writeCompleteMilestone(base, 'M007');
+    // M008 depends on both M009 and M010
+    writeContext(base, 'M008', 'depends_on: [M009, M010]', 'Parallel');
+    writeContext(base, 'M009', '', 'Visibility');
+    writeContext(base, 'M010', '', 'Other');
+
+    // Verify both deps are parsed
+    const contentBefore = readContextFile(base, 'M008');
+    const depsBefore = parseContextDependsOn(contentBefore);
+    assertEq(depsBefore.length, 2, 'M008 has 2 deps before');
+
+    // Simulate removing only M009 dep (keep M010)
+    const content = readContextFile(base, 'M008');
+    const updated = content.replace('depends_on: [M009, M010]', 'depends_on: [M010]');
+    writeFileSync(join(base, '.gsd', 'milestones', 'M008', 'M008-CONTEXT.md'), updated);
+
+    // 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');
+
+  } finally {
+    cleanup(base);
+  }
+}
+
+report();

package/dist/resources/extensions/gsd/tests/stale-worktree-cwd.test.ts

@@ -0,0 +1,139 @@
+/**
+ * stale-worktree-cwd.test.ts — Tests for #608 fix.
+ *
+ * Verifies that when process.cwd() is inside a stale .gsd/worktrees/ path,
+ * startAuto escapes back to the project root before proceeding.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, existsSync, realpathSync, writeFileSync } from "node:fs";
+import { join, sep } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import {
+  createAutoWorktree,
+  teardownAutoWorktree,
+  mergeMilestoneToMain,
+} from "../auto-worktree.ts";
+
+function run(command: string, cwd: string): string {
+  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function createTempRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "stale-wt-test-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+  return dir;
+}
+
+// ─── escapeStaleWorktree is called by startAuto, test the detection logic ────
+
+test("detects stale worktree path and extracts project root", () => {
+  // Simulate the path pattern: /project/.gsd/worktrees/M004/...
+  const projectRoot = "/Users/test/myproject";
+  const stalePath = `${projectRoot}${sep}.gsd${sep}worktrees${sep}M004`;
+
+  const marker = `${sep}.gsd${sep}worktrees${sep}`;
+  const idx = stalePath.indexOf(marker);
+
+  assert.ok(idx !== -1, "marker found in stale path");
+  assert.equal(stalePath.slice(0, idx), projectRoot, "project root extracted correctly");
+});
+
+test("does not trigger on normal project path", () => {
+  const normalPath = "/Users/test/myproject";
+  const marker = `${sep}.gsd${sep}worktrees${sep}`;
+  const idx = normalPath.indexOf(marker);
+
+  assert.equal(idx, -1, "marker not found in normal path");
+});
+
+// ─── Integration: mergeMilestoneToMain restores cwd ─────────────────────────
+
+test("mergeMilestoneToMain restores cwd to project root", () => {
+  const savedCwd = process.cwd();
+  let tempDir = "";
+
+  try {
+    tempDir = createTempRepo();
+
+    // Create milestone planning artifacts
+    const msDir = join(tempDir, ".gsd", "milestones", "M050");
+    mkdirSync(msDir, { recursive: true });
+    writeFileSync(join(msDir, "CONTEXT.md"), "# M050 Context\n");
+    const roadmap = [
+      "# M050: Test Milestone",
+      "**Vision**: testing",
+      "## Success Criteria",
+      "- It works",
+      "## Slices",
+      "- [x] S01 — First slice",
+    ].join("\n");
+    writeFileSync(join(msDir, "ROADMAP.md"), roadmap);
+    run("git add .", tempDir);
+    run("git commit -m \"add milestone\"", tempDir);
+
+    // Create auto-worktree (enters the worktree dir)
+    const wtPath = createAutoWorktree(tempDir, "M050");
+    assert.equal(process.cwd(), wtPath, "cwd is in worktree after create");
+
+    // Add a change in the worktree
+    writeFileSync(join(wtPath, "feature.txt"), "new feature\n");
+    run("git add .", wtPath);
+    run("git commit -m \"feat: add feature\"", wtPath);
+
+    // Merge back — should restore cwd to tempDir
+    mergeMilestoneToMain(tempDir, "M050", roadmap);
+
+    assert.equal(process.cwd(), tempDir, "cwd restored to project root after merge");
+    assert.ok(!existsSync(wtPath), "worktree directory removed after merge");
+  } finally {
+    process.chdir(savedCwd);
+    if (tempDir && existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+});
+
+// ─── Integration: stale worktree directory is detectable ────────────────────
+
+test("process.cwd() inside removed worktree is recoverable", () => {
+  const savedCwd = process.cwd();
+  let tempDir = "";
+
+  try {
+    tempDir = createTempRepo();
+
+    // Create a .gsd/worktrees/M099 directory to simulate stale state
+    const staleWtDir = join(tempDir, ".gsd", "worktrees", "M099");
+    mkdirSync(staleWtDir, { recursive: true });
+
+    // Enter the stale directory
+    process.chdir(staleWtDir);
+    const cwdBefore = process.cwd();
+    assert.ok(cwdBefore.includes(`${sep}.gsd${sep}worktrees${sep}`), "cwd is inside worktree dir");
+
+    // Simulate escapeStaleWorktree logic
+    const marker = `${sep}.gsd${sep}worktrees${sep}`;
+    const idx = cwdBefore.indexOf(marker);
+    assert.ok(idx !== -1, "marker found");
+
+    const projectRoot = cwdBefore.slice(0, idx);
+    process.chdir(projectRoot);
+
+    assert.equal(process.cwd(), tempDir, "successfully escaped to project root");
+  } finally {
+    process.chdir(savedCwd);
+    if (tempDir && existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+});

package/dist/resources/extensions/gsd/worktree-manager.ts

@@ -94,7 +94,7 @@ export function worktreeBranchName(name: string): string {
  *
  * @param opts.branch — override the default `worktree/<name>` branch name
  */
-export function createWorktree(basePath: string, name: string, opts: { branch?: string } = {}): WorktreeInfo {
+export function createWorktree(basePath: string, name: string, opts: { branch?: string; startPoint?: string } = {}): WorktreeInfo {
   // Validate name: alphanumeric, hyphens, underscores only
   if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
     throw new Error(`Invalid worktree name "${name}". Use only letters, numbers, hyphens, and underscores.`);
@@ -114,9 +114,12 @@ export function createWorktree(basePath: string, name: string, opts: { branch?:
   // Prune any stale worktree entries from a previous removal
   nativeWorktreePrune(basePath);
 
+  // Use the explicit start point (e.g. integration branch) if provided,
+  // otherwise fall back to the repo's detected main branch.
+  const startPoint = opts.startPoint ?? nativeDetectMainBranch(basePath);
+
   // Check if the branch already exists (leftover from a previous worktree)
   const branchAlreadyExists = nativeBranchExists(basePath, branch);
-  const mainBranch = nativeDetectMainBranch(basePath);
 
   if (branchAlreadyExists) {
     // Check if the branch is actively used by an existing worktree.
@@ -130,11 +133,11 @@ export function createWorktree(basePath: string, name: string, opts: { branch?:
       );
     }
 
-    // Reset the stale branch to current main, then attach worktree to it
-    nativeBranchForceReset(basePath, branch, mainBranch);
+    // Reset the stale branch to the start point, then attach worktree to it
+    nativeBranchForceReset(basePath, branch, startPoint);
     nativeWorktreeAdd(basePath, wtPath, branch);
   } else {
-    nativeWorktreeAdd(basePath, wtPath, branch, true, mainBranch);
+    nativeWorktreeAdd(basePath, wtPath, branch, true, startPoint);
   }
 
   return {

package/dist/resources/extensions/gsd/worktree.ts

@@ -76,6 +76,28 @@ export function detectWorktreeName(basePath: string): string | null {
   return name || null;
 }
 
+/**
+ * Resolve the project root from a path that may be inside a worktree.
+ * If the path contains `/.gsd/worktrees/<name>/`, returns the portion
+ * before `/.gsd/`. Otherwise returns the input unchanged.
+ *
+ * Use this in commands that call `process.cwd()` to ensure they always
+ * operate against the real project root, not a worktree subdirectory.
+ */
+export function resolveProjectRoot(basePath: string): string {
+  const normalizedPath = basePath.replaceAll("\\", "/");
+  const marker = "/.gsd/worktrees/";
+  const idx = normalizedPath.indexOf(marker);
+  if (idx === -1) return basePath;
+  // Return the original path up to the .gsd/ marker (un-normalized)
+  // Account for potential OS-specific separators
+  const sep = basePath.includes("\\") ? "\\" : "/";
+  const markerOs = `${sep}.gsd${sep}worktrees${sep}`;
+  const idxOs = basePath.indexOf(markerOs);
+  if (idxOs !== -1) return basePath.slice(0, idxOs);
+  return basePath.slice(0, idx);
+}
+
 /**
  * Get the slice branch name, namespaced by worktree when inside one.
  *

package/dist/resources/extensions/shared/next-action-ui.ts

@@ -118,7 +118,7 @@ export async function showNextAction(
 		}
 	});
 
-	return ctx.ui.custom<string>((_tui: TUI, theme: Theme, _kb, done) => {
+	const result = await ctx.ui.custom<string>((_tui: TUI, theme: Theme, _kb, done) => {
 		let cursorIdx = defaultIdx;
 		let cachedLines: string[] | undefined;
 
@@ -194,4 +194,19 @@ export async function showNextAction(
 
 		return { render, invalidate: () => { cachedLines = undefined; }, handleInput };
 	});
+
+	// Fallback for RPC mode where ctx.ui.custom() returns undefined (#447).
+	// Fall back to ctx.ui.select() which IS implemented in RPC mode.
+	if (result === undefined || result === null) {
+		const labels = allActions.map(a => {
+			const tag = a.recommended ? " (recommended)" : "";
+			return `${a.label}${tag}: ${a.description}`;
+		});
+		const selected = await ctx.ui.select(opts.title, labels);
+		if (selected === undefined || selected === null) return "not_yet";
+		const idx = labels.indexOf(selected as string);
+		return idx >= 0 ? allActions[idx].id : "not_yet";
+	}
+
+	return result;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.17.0",
+  "version": "2.18.0",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {

package/packages/pi-coding-agent/dist/cli/args.d.ts

@@ -33,6 +33,11 @@ export interface Args {
     themes?: string[];
     noThemes?: boolean;
     listModels?: string | true;
+    discover?: boolean;
+    addProvider?: string;
+    addProviderBaseUrl?: string;
+    addProviderApiKey?: string;
+    discoverModels?: string | true;
     offline?: boolean;
     verbose?: boolean;
     messages: string[];

package/packages/pi-coding-agent/dist/cli/args.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../../src/cli/args.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEjE,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;AAE3C,MAAM,WAAW,IAAI;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,8EAA8E;IAC9E,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC,CAAC;CAC5C;AAID,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,aAAa,CAE1E;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,SAAS,GAAG,QAAQ,CAAA;CAAE,CAAC,GAAG,IAAI,CA0H5G;AAED,wBAAgB,SAAS,IAAI,IAAI,CA0IhC"}
+{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../../src/cli/args.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEjE,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;AAE3C,MAAM,WAAW,IAAI;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,8EAA8E;IAC9E,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC,CAAC;CAC5C;AAID,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,aAAa,CAE1E;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,SAAS,GAAG,QAAQ,CAAA;CAAE,CAAC,GAAG,IAAI,CAsI5G;AAED,wBAAgB,SAAS,IAAI,IAAI,CA8IhC"}

package/packages/pi-coding-agent/dist/cli/args.js

@@ -129,6 +129,23 @@ export function parseArgs(args, extensionFlags) {
                 result.listModels = true;
             }
         }
+        else if (arg === "--discover") {
+            result.discover = true;
+        }
+        else if (arg === "--add-provider" && i + 1 < args.length) {
+            result.addProvider = args[++i];
+        }
+        else if (arg === "--base-url" && i + 1 < args.length) {
+            result.addProviderBaseUrl = args[++i];
+        }
+        else if (arg === "--discover-models") {
+            if (i + 1 < args.length && !args[i + 1].startsWith("-") && !args[i + 1].startsWith("@")) {
+                result.discoverModels = args[++i];
+            }
+            else {
+                result.discoverModels = true;
+            }
+        }
         else if (arg === "--verbose") {
             result.verbose = true;
         }
@@ -201,6 +218,10 @@ ${chalk.bold("Options:")}
   --no-themes                    Disable theme discovery and loading
   --export <file>                Export session file to HTML and exit
   --list-models [search]         List available models (with optional fuzzy search)
+  --discover                     Include discovered models in --list-models output
+  --discover-models [provider]   Discover models from provider APIs (all or specific)
+  --add-provider <name>          Add a provider to models.json (use with --base-url, --api-key)
+  --base-url <url>               Base URL for --add-provider
   --verbose                      Force verbose startup (overrides quietStartup setting)
   --offline                      Disable startup network operations (same as PI_OFFLINE=1)
   --help, -h                     Show this help