@opengsd/gsd-pi 1.2.0-dev.d6c5343c → 1.2.0-dev.ddc97c10

package/src/resources/extensions/gsd/tools/reopen-milestone.ts

@@ -15,7 +15,7 @@ import {
   reopenMilestoneCascade,
 } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -98,7 +98,7 @@ export async function handleReopenMilestone(
 
   // ── Post-mutation hook ───────────────────────────────────────────────────
   try {
-    await renderAllProjections(basePath, params.milestoneId);
+    await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
     writeManifest(basePath);
     appendEvent(basePath, {
       cmd: "reopen-milestone",

package/src/resources/extensions/gsd/tools/reopen-slice.ts

@@ -16,7 +16,7 @@ import {
   reopenSliceCascade,
 } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -97,7 +97,7 @@ export async function handleReopenSlice(
 
   // ── Post-mutation hook ───────────────────────────────────────────────────
   try {
-    await renderAllProjections(basePath, params.milestoneId);
+    await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
     writeManifest(basePath);
     appendEvent(basePath, {
       cmd: "reopen-slice",

package/src/resources/extensions/gsd/tools/reopen-task.ts

@@ -19,7 +19,7 @@ import {
 } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { isClosedStatus } from "../status-guards.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -119,7 +119,7 @@ export async function handleReopenTask(
 
   // ── Post-mutation hook ───────────────────────────────────────────────────
   try {
-    await renderAllProjections(basePath, params.milestoneId);
+    await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
     writeManifest(basePath);
     appendEvent(basePath, {
       cmd: "reopen-task",

package/src/resources/extensions/gsd/tools/replan-slice.ts

@@ -13,7 +13,7 @@ import { invalidateStateCache } from "../state.js";
 import { isClosedStatus } from "../status-guards.js";
 import { isNonEmptyString } from "../validation.js";
 import { renderPlanFromDb, renderReplanFromDb } from "../markdown-renderer.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -216,7 +216,7 @@ export async function handleReplanSlice(
 
     // ── Post-mutation hook: projections, manifest, event log ─────
     try {
-      await renderAllProjections(basePath, params.milestoneId);
+      await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
       writeManifest(basePath);
       appendEvent(basePath, {
         cmd: "replan-slice",

package/src/resources/extensions/gsd/tools/workflow-tool-executors.ts

@@ -19,9 +19,10 @@ import {
 } from "../gsd-db.js";
 import { GATE_REGISTRY } from "../gate-registry.js";
 import { generateRequirementsMd, saveArtifactToDb } from "../db-writer.js";
-import { clearPathCache, relSliceFile, resolveGsdPathContract, resolveMilestoneFile, resolveSliceFile } from "../paths.js";
+import { clearPathCache, normalizeRealPath, relSliceFile, resolveGsdPathContract, resolveMilestoneFile, resolveSliceFile } from "../paths.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { unlinkSync } from "node:fs";
+import { hostname } from "node:os";
 import { join } from "node:path";
 import type { CompleteMilestoneParams } from "./complete-milestone.js";
 import { handleCompleteMilestone } from "./complete-milestone.js";
@@ -48,13 +49,21 @@ import { logError, logWarning } from "../workflow-logger.js";
 import { invalidateStateCache } from "../state.js";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { parseProject } from "../schemas/parsers.js";
-import { getAutoRuntimeSnapshot } from "../auto-runtime-state.js";
+import { autoSession, getAutoRuntimeSnapshot, isAutoActive } from "../auto-runtime-state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
 import {
   prepareUatRun,
   saveUatAttemptArtifact,
   type UatResultSaveParams,
 } from "../uat-run.js";
+import { registerAutoWorker, markWorkerStopping, getAutoWorker } from "../db/auto-workers.js";
+import {
+  claimMilestoneLease,
+  releaseMilestoneLease,
+  getMilestoneLease,
+  refreshMilestoneLease,
+  milestoneLeaseTtlSeconds,
+} from "../db/milestone-leases.js";
 export type {
   UatCheckResultInput,
   UatEvidenceRef,
@@ -105,6 +114,24 @@ function blockIfWrongAutoUnit(requiredUnitType: string, operation: string): Tool
   };
 }
 
+function milestoneLeaseConflictResult(
+  milestoneId: string,
+  byWorker: string,
+  expiresAt: string,
+): ToolExecutionResult {
+  return {
+    content: [{ type: "text", text: `Milestone ${milestoneId} is currently leased by ${byWorker}. Retry after ${expiresAt}.` }],
+    details: {
+      operation: "plan_milestone",
+      error: "milestone_lease_conflict",
+      milestoneId,
+      byWorker,
+      expiresAt,
+    },
+    isError: true,
+  };
+}
+
 export interface SummarySaveParams {
   milestone_id?: string;
   slice_id?: string;
@@ -1244,7 +1271,48 @@ export async function executePlanMilestone(
     isError: true,
       };
   }
+  let workerId: string | null = null;
+  let acquiredToken: number | null = null;
+  let leaseRefreshTimer: ReturnType<typeof setInterval> | undefined;
   try {
+    // Re-read at the gate so a peer-created milestone is not treated as fresh.
+    const milestoneExists = getMilestone(params.milestoneId) !== null;
+    if (milestoneExists) {
+      const heldLease = getMilestoneLease(params.milestoneId);
+      if (heldLease?.status === "held" && Date.parse(heldLease.expires_at) > Date.now()) {
+        const holder = getAutoWorker(heldLease.worker_id);
+        // Let the one-shot claim path recover stale same-process worker rows.
+        const projectRoot = normalizeRealPath(basePath);
+        const isOurAutoLease = isAutoActive() && heldLease.worker_id === autoSession.workerId;
+        const holderIsOneShotReentrantPeer = !isAutoActive()
+          && !!holder
+          && holder.host === hostname()
+          && holder.pid === process.pid
+          && holder.project_root_realpath === projectRoot;
+        if (holder?.status === "active" && !isOurAutoLease && !holderIsOneShotReentrantPeer) {
+          return milestoneLeaseConflictResult(params.milestoneId, heldLease.worker_id, heldLease.expires_at);
+        }
+      }
+    }
+
+    // Fresh creation cannot claim a lease because the FK row does not exist.
+    // In-process auto already owns its lease; re-claiming would bump its token.
+    if (!isAutoActive() && milestoneExists) {
+      workerId = registerAutoWorker({ projectRootRealpath: normalizeRealPath(basePath) });
+      const lease = claimMilestoneLease(workerId, params.milestoneId);
+      if (!lease.ok) {
+        return milestoneLeaseConflictResult(params.milestoneId, lease.byWorker, lease.expiresAt);
+      }
+      acquiredToken = lease.token;
+
+      const leaseRefreshMs = (milestoneLeaseTtlSeconds() / 2) * 1000;
+      leaseRefreshTimer = setInterval(() => {
+        if (acquiredToken !== null && workerId !== null) {
+          refreshMilestoneLease(workerId, params.milestoneId, acquiredToken);
+        }
+      }, leaseRefreshMs);
+    }
+
     const result = await handlePlanMilestone(params, basePath);
     if ("error" in result) {
       return {
@@ -1270,6 +1338,17 @@ export async function executePlanMilestone(
     isError: true,
       };
   }
+  finally {
+    if (leaseRefreshTimer !== undefined) {
+      clearInterval(leaseRefreshTimer);
+    }
+    if (workerId !== null && acquiredToken !== null) {
+      releaseMilestoneLease(workerId, params.milestoneId, acquiredToken);
+    }
+    if (workerId !== null) {
+      markWorkerStopping(workerId);
+    }
+  }
 }
 
 export async function executePlanSlice(

package/src/resources/extensions/gsd/verification-verdict.ts

@@ -15,6 +15,9 @@ export interface VerificationVerdict {
   failureContext: string;
 }
 
+export const NO_HOST_CHECKS_FAILURE_CONTEXT =
+  "No runnable host-owned verification command was discovered. Add project verification_commands in .gsd/PREFERENCES.md or a runnable task-plan Verify command, then resume with /gsd next.";
+
 export function decideVerificationVerdict(
   unitType: string,
   result: VerificationGateResult,
@@ -33,8 +36,7 @@ export function decideVerificationVerdict(
       passed: false,
       reason: "no-host-checks",
       retryable: false,
-      failureContext:
-        "No runnable host-owned verification command was discovered. Add project verification_commands or a runnable task-plan Verify command before completing this execute-task.",
+      failureContext: NO_HOST_CHECKS_FAILURE_CONTEXT,
     };
   }
 

package/src/resources/extensions/shared/gsd-browser-cli.ts

@@ -55,6 +55,24 @@ function parseGsdBrowserVersion(output: string): string | null {
   return output.match(/\b(\d+\.\d+\.\d+)\b/)?.[1] ?? null;
 }
 
+function splitCommandLine(commandLine: string): string[] {
+  const parts = commandLine.match(/(?:"[^"]*"|'[^']*'|[^\s"']+)/g) ?? [];
+  return parts.map((part) => {
+    const quote = part[0];
+    if ((quote === '"' || quote === "'") && part.endsWith(quote)) {
+      return part.slice(1, -1);
+    }
+    return part;
+  });
+}
+
+function buildPathGsdBrowserVersionInvocation(platform: NodeJS.Platform): { command: string; args: string[] } {
+  if (platform === "win32") {
+    return { command: "cmd", args: ["/d", "/s", "/c", "gsd-browser", "--version"] };
+  }
+  return { command: "gsd-browser", args: ["--version"] };
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -86,7 +104,8 @@ function resolvePathGsdBrowserVersion(env: NodeJS.ProcessEnv): string | null {
   if (cachedPathProbeVersion !== undefined) return cachedPathProbeVersion;
 
   try {
-    cachedPathProbeVersion = parseGsdBrowserVersion(execFileSync("gsd-browser", ["--version"], {
+    const invocation = buildPathGsdBrowserVersionInvocation(process.platform);
+    cachedPathProbeVersion = parseGsdBrowserVersion(execFileSync(invocation.command, invocation.args, {
       encoding: "utf-8",
       env,
       stdio: ["ignore", "pipe", "ignore"],
@@ -216,7 +235,8 @@ export function resolveGsdBrowserMcpLaunchConfig(
   const serverName = env.GSD_BROWSER_MCP_NAME?.trim() || GSD_BROWSER_MCP_SERVER_NAME;
   const explicitArgs = parseJsonEnv<unknown>(env, "GSD_BROWSER_MCP_ARGS");
   const explicitEnv = parseJsonEnv<Record<string, string>>(env, "GSD_BROWSER_MCP_ENV");
-  const explicitCommand = env.GSD_BROWSER_MCP_COMMAND?.trim();
+  const explicitCommandLine = env.GSD_BROWSER_MCP_COMMAND?.trim();
+  const [explicitCommand, ...explicitCommandArgs] = explicitCommandLine ? splitCommandLine(explicitCommandLine) : [];
   const explicitCliPath = resolveExplicitGsdBrowserCliPath(env);
   const preferPathCli = !explicitCommand && !explicitCliPath && shouldPreferPathGsdBrowser(env);
   const bundledCliPath = !explicitCommand && !explicitCliPath && !preferPathCli
@@ -241,6 +261,7 @@ export function resolveGsdBrowserMcpLaunchConfig(
   const args = Array.isArray(explicitArgs) && explicitArgs.length > 0
     ? explicitArgs.map(String)
     : [
+        ...explicitCommandArgs,
         ...(bundledCliPath ? [bundledCliPath] : []),
         "mcp",
         "--session",

package/src/resources/shared/gsd-browser-path-sync.ts

@@ -0,0 +1,273 @@
+import { execFileSync } from 'node:child_process'
+import { chmodSync, copyFileSync, existsSync, lstatSync, readlinkSync, realpathSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, isAbsolute, join, delimiter as pathDelimiter, resolve as resolvePath } from 'node:path'
+import { isPnpmInstall, pathStartsWith } from './package-manager-detection.js'
+
+export interface GsdBrowserPathReconcileResult {
+  action: 'none' | 'synced' | 'shadowed'
+  pathCli?: string
+  installedCli?: string
+  syncTarget?: string
+  message?: string
+}
+
+function isBunGlobalInstall(argv1: string | undefined, env: NodeJS.ProcessEnv): boolean {
+  if ('bun' in process.versions) return true
+  if (!argv1) return false
+
+  const bunBinDirs: string[] = []
+  if (env.BUN_INSTALL) bunBinDirs.push(join(env.BUN_INSTALL, 'bin'))
+  bunBinDirs.push(join(homedir(), '.bun', 'bin'))
+
+  return bunBinDirs.some((dir) => pathStartsWith(argv1, dir))
+}
+
+function gsdBrowserBinaryName(platform: NodeJS.Platform): string {
+  return platform === 'win32' ? 'gsd-browser.cmd' : 'gsd-browser'
+}
+
+function tryResolveFromBinDir(binDir: string, platform: NodeJS.Platform): string | null {
+  const primary = join(binDir, gsdBrowserBinaryName(platform))
+  if (existsSync(primary)) return primary
+
+  if (platform === 'win32') {
+    const fallback = join(binDir, 'gsd-browser')
+    if (existsSync(fallback)) return fallback
+  }
+
+  return null
+}
+
+function tryResolveFromPackageRoot(
+  rootDir: string,
+  platform: NodeJS.Platform,
+): string | null {
+  const candidate = join(rootDir, '@opengsd', 'gsd-browser', 'bin', gsdBrowserBinaryName(platform))
+  if (existsSync(candidate)) return candidate
+
+  if (platform === 'win32') {
+    const fallback = join(rootDir, '@opengsd', 'gsd-browser', 'bin', 'gsd-browser')
+    if (existsSync(fallback)) return fallback
+  }
+
+  return null
+}
+
+function tryExecLookup(
+  command: string,
+  args: string[],
+  env: NodeJS.ProcessEnv,
+  platform: NodeJS.Platform,
+  resolve: (dir: string, platform: NodeJS.Platform) => string | null,
+): string | null {
+  try {
+    const dir = execFileSync(command, args, {
+      encoding: 'utf-8',
+      env,
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 5000,
+    }).trim()
+    return resolve(dir, platform)
+  } catch {
+    return null
+  }
+}
+
+function resolvePathBinary(env: NodeJS.ProcessEnv, platform: NodeJS.Platform): string | null {
+  if (platform === 'win32') {
+    try {
+      const out = execFileSync('where', ['gsd-browser'], {
+        encoding: 'utf-8',
+        env,
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: 5000,
+      }).trim()
+      const first = out.split(/\r?\n/).map((line) => line.trim()).find(Boolean)
+      return first && existsSync(first) ? first : null
+    } catch {
+      return null
+    }
+  }
+
+  for (const entry of (env.PATH ?? '').split(pathDelimiter)) {
+    if (!entry) continue
+    const candidate = join(entry, 'gsd-browser')
+    if (existsSync(candidate)) return candidate
+  }
+
+  return null
+}
+
+function resolveRealPath(pathValue: string): string {
+  try {
+    return realpathSync(pathValue)
+  } catch {
+    return resolvePath(pathValue)
+  }
+}
+
+function resolveSymlinkTarget(pathCli: string): string {
+  try {
+    const stat = lstatSync(pathCli)
+    if (!stat.isSymbolicLink()) return pathCli
+
+    const target = readlinkSync(pathCli)
+    return isAbsolute(target) ? target : resolvePath(dirname(pathCli), target)
+  } catch {
+    // PATH entry vanished or is inaccessible between resolution and sync.
+    // Fall back to the original path; subsequent sync will surface a useful
+    // error rather than escaping as an unhandled throw.
+    return pathCli
+  }
+}
+
+function resolveHomeDir(env: NodeJS.ProcessEnv): string {
+  const fromEnv = env.HOME?.trim() || env.USERPROFILE?.trim()
+  return resolvePath(fromEnv || homedir())
+}
+
+function canAutoSyncTarget(targetPath: string, env: NodeJS.ProcessEnv): boolean {
+  const home = resolveHomeDir(env)
+  const resolved = resolvePath(targetPath)
+  return pathStartsWith(resolved, home)
+}
+
+function syncBinary(installedCli: string, targetPath: string, platform: NodeJS.Platform): void {
+  const source = resolveRealPath(installedCli)
+  copyFileSync(source, targetPath)
+  if (platform !== 'win32') {
+    chmodSync(targetPath, 0o755)
+  }
+}
+
+/**
+ * Resolve the gsd-browser binary installed by the active global package manager.
+ */
+export function resolveGlobalGsdBrowserCliPath(
+  options: { env?: NodeJS.ProcessEnv; argv1?: string; platform?: NodeJS.Platform } = {},
+): string | null {
+  const env = options.env ?? process.env
+  const argv1 = options.argv1 ?? process.argv[1]
+  const platform = options.platform ?? process.platform
+
+  if (isBunGlobalInstall(argv1, env)) {
+    return (
+      tryExecLookup('bun', ['pm', 'bin', '-g'], env, platform, tryResolveFromBinDir)
+      ?? (env.BUN_INSTALL ? tryResolveFromBinDir(join(env.BUN_INSTALL, 'bin'), platform) : null)
+      ?? tryResolveFromBinDir(join(homedir(), '.bun', 'bin'), platform)
+    )
+  }
+
+  if (isPnpmInstall(argv1, env)) {
+    return (
+      tryExecLookup('pnpm', ['bin', '-g'], env, platform, tryResolveFromBinDir)
+      ?? tryExecLookup('pnpm', ['root', '-g'], env, platform, tryResolveFromPackageRoot)
+    )
+  }
+
+  return (
+    tryExecLookup('npm', ['bin', '-g'], env, platform, tryResolveFromBinDir)
+    ?? tryExecLookup('npm', ['root', '-g'], env, platform, tryResolveFromPackageRoot)
+  )
+}
+
+/**
+ * Resolve the gsd-browser binary that wins on PATH (`command -v` / `where`).
+ */
+export function resolveGsdBrowserOnPath(
+  env: NodeJS.ProcessEnv = process.env,
+  platform: NodeJS.Platform = process.platform,
+): string | null {
+  return resolvePathBinary(env, platform)
+}
+
+/**
+ * After a global gsd-browser install, ensure the PATH-resolved binary matches
+ * the freshly installed global binary when an older copy is shadowing it.
+ */
+export function reconcileGsdBrowserPathAfterInstall(
+  options: {
+    latestVersion: string
+    compareSemver: (a: string, b: string) => number
+    resolvePathVersion: (env: NodeJS.ProcessEnv) => string | null
+    env?: NodeJS.ProcessEnv
+    argv1?: string
+    platform?: NodeJS.Platform
+  },
+): GsdBrowserPathReconcileResult {
+  const env = options.env ?? process.env
+  const argv1 = options.argv1 ?? process.argv[1]
+  const platform = options.platform ?? process.platform
+
+  const installedCli = resolveGlobalGsdBrowserCliPath({ env, argv1, platform })
+  if (!installedCli) {
+    return { action: 'none' }
+  }
+
+  const pathCli = resolveGsdBrowserOnPath(env, platform)
+  const installedReal = resolveRealPath(installedCli)
+  if (pathCli && resolveRealPath(pathCli) === installedReal) {
+    return { action: 'none', pathCli, installedCli }
+  }
+
+  const pathVersion = options.resolvePathVersion(env)
+  if (pathVersion && options.compareSemver(pathVersion, options.latestVersion) >= 0) {
+    return { action: 'none', pathCli: pathCli ?? undefined, installedCli }
+  }
+
+  if (!pathCli) {
+    return {
+      action: 'shadowed',
+      installedCli,
+      message:
+        'Installed gsd-browser globally, but no gsd-browser was found on PATH. Add your package manager global bin directory to PATH.',
+    }
+  }
+
+  const syncTarget = resolveSymlinkTarget(pathCli)
+  if (!canAutoSyncTarget(syncTarget, env)) {
+    return {
+      action: 'shadowed',
+      pathCli,
+      installedCli,
+      syncTarget,
+      message:
+        `PATH resolves gsd-browser to ${pathCli}, but the updated global install is at ${installedCli}. ` +
+        'Move your package manager global bin directory ahead of the stale location on PATH, or update the stale binary manually.',
+    }
+  }
+
+  let syncSucceeded = false
+  try {
+    syncBinary(installedCli, syncTarget, platform)
+    syncSucceeded = true
+  } catch {
+    // Fall through to shadowed guidance.
+  }
+
+  if (syncSucceeded) {
+    const refreshedVersion = options.resolvePathVersion(env)
+    const verified = refreshedVersion !== null
+      && options.compareSemver(refreshedVersion, options.latestVersion) >= 0
+    return {
+      action: 'synced',
+      pathCli,
+      installedCli,
+      syncTarget,
+      message: verified
+        ? `Synced PATH-resolved gsd-browser at ${syncTarget} to the updated global install.`
+        : `Synced PATH-resolved gsd-browser at ${syncTarget} to the updated global install. Could not verify the new version on PATH; restart your shell or rerun if it still reports the old version.`,
+    }
+  }
+
+  return {
+    action: 'shadowed',
+    pathCli,
+    installedCli,
+    syncTarget,
+    message:
+      `PATH resolves gsd-browser to ${pathCli}, but the updated global install is at ${installedCli}. ` +
+      'Move your package manager global bin directory ahead of the stale location on PATH, or update the stale binary manually.',
+  }
+}

package/src/resources/shared/package-manager-detection.ts

@@ -12,7 +12,7 @@ function hasPnpmPath(value: string | undefined): boolean {
   )
 }
 
-function pathStartsWith(pathValue: string | undefined, dir: string): boolean {
+export function pathStartsWith(pathValue: string | undefined, dir: string): boolean {
   if (!pathValue) return false
   const resolvedPath = resolvePath(pathValue)
   const resolvedDir = resolvePath(dir)