@opengsd/gsd-core 1.20.1 → 1.21.0

package/gsd-core/bin/lib/roadmap-upgrade.cjs

@@ -14,6 +14,9 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const shell_command_projection_cjs_1 = require("./shell-command-projection.cjs");
 const phase_entry_grammar_cjs_1 = require("./phase-entry-grammar.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- config-file-read.cjs is an export= CommonJS module
+const configFileReadMod = require("./config-file-read.cjs");
+const { readConfigFileBounded } = configFileReadMod;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const planningWorkspace = require("./planning-workspace.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -882,7 +885,10 @@ function computeBracketPlan(cwd) {
     };
     let configData = {};
     try {
-        configData = JSON.parse(node_fs_1.default.readFileSync(configPath, 'utf8'));
+        // Bounded read (#5759): a FIFO/device/oversized config is treated like an absent one.
+        const rawConfig = readConfigFileBounded(configPath);
+        if (rawConfig !== null)
+            configData = JSON.parse(rawConfig);
     }
     catch { /* config may not exist */ }
     const projectCode = typeof configData['project_code'] === 'string' && configData['project_code'].length > 0
@@ -1086,7 +1092,7 @@ function computeBracketPlan(cwd) {
     // never `null` (unlimited). Comparing under a DIFFERENT rule than the one
     // that created the directory refused two-milestone roadmaps the
     // tooling's own commands produced.
-    const slugify = (text) => (coreUtilsMod.generateSlugInternal(text.replace(/\(INSERTED\)/i, '').trim()) ?? '');
+    const slugify = (text) => (coreUtilsMod.generateSlugInternal((0, phase_entry_grammar_cjs_1.stripInsertedMarker)(text)) ?? '');
     // #4144 round 7 W2, corrected round 8 B1: a plan-level ambiguity check
     // that runs BEFORE the resolution loop below and never touches its
     // (unmodified, round-6) algorithm. For every directory that structurally
@@ -1621,7 +1627,10 @@ function computeMigrationPlan(cwd, options = {}) {
     // ── Check config for existing convention ─────────────────────────────────
     let configData = {};
     try {
-        configData = JSON.parse(node_fs_1.default.readFileSync(configPath, 'utf8'));
+        // Bounded read (#5759): a FIFO/device/oversized config is treated like an absent one.
+        const rawConfig = readConfigFileBounded(configPath);
+        if (rawConfig !== null)
+            configData = JSON.parse(rawConfig);
     }
     catch { /* config may not exist */ }
     if (configData['phase_id_convention'] === 'milestone-prefixed') {
@@ -2110,9 +2119,19 @@ function applyMigration(cwd, plan, options = {}) {
         if (plan.phases.length > 0 || plan.roadmapEdits.length > 0) {
             let configData = {};
             try {
-                configData = JSON.parse(node_fs_1.default.readFileSync(configPath, 'utf8'));
+                // Bounded read (#5759): the stamp below is written to configPath, so a FIFO/device/
+                // oversized config is refused (and rolled back) rather than read or written blindly.
+                const rawConfig = readConfigFileBounded(configPath);
+                if (rawConfig !== null)
+                    configData = JSON.parse(rawConfig);
+            }
+            catch (err) {
+                const code = err.code;
+                if (code === 'ENXIO' || code === 'EISDIR' || code === 'EFBIG') {
+                    throw new Error(`config.json cannot be updated: it is not a regular file within the size limit (${code})`);
+                }
+                /* config may not exist yet, or may not parse */
             }
-            catch { /* config may not exist yet */ }
             configData['phase_id_convention'] = plan.targetConvention ?? 'milestone-prefixed';
             snapshotFile(configPath);
             try {

package/gsd-core/bin/lib/roadmap.cjs

@@ -171,7 +171,7 @@ function searchPhaseInContent(content, escapedPhase, phaseNum, convention) {
         }
         return null;
     }
-    const phaseName = headerMatch[1].trim();
+    const phaseName = (0, phase_entry_grammar_cjs_1.stripInsertedMarker)(headerMatch[1]);
     const headerIndex = headings[headingIndex].offset;
     const currentHeading = headings[headingIndex];
     const nextHeading = headings
@@ -395,7 +395,7 @@ function collectAnalyzePhases(cwd, content, phasesDir, phaseDirNames, convention
         if (isSentinelPhase(phaseNum, bracketId))
             continue;
         detailKeys.add(occurrenceKey(phaseNum, bracketId));
-        const phaseName = match[2 + G].replace(/\(INSERTED\)/i, '').trim();
+        const phaseName = (0, phase_entry_grammar_cjs_1.stripInsertedMarker)(match[2 + G]);
         // Extract goal from the section
         const sectionStart = match.index;
         const restOfContent = content.slice(sectionStart);

package/gsd-core/bin/lib/runtime-artifact-conversion.cjs

@@ -2779,9 +2779,10 @@ function convertClaudeAgentToCopilotAgent(content, isGlobal = false) {
     const name = extractFrontmatterField(frontmatter, 'name') || 'unknown';
     const description = extractFrontmatterField(frontmatter, 'description') || '';
     const color = extractFrontmatterField(frontmatter, 'color');
-    const toolsRaw = extractFrontmatterField(frontmatter, 'tools') || '';
-    // CONV-04 + CONV-05: Map tools, deduplicate, format as JSON array
-    const claudeTools = toolsRaw.split(',').map(t => t.trim()).filter(Boolean);
+    // CONV-04 + CONV-05: Map tools, deduplicate, format as JSON array.
+    // parseFrontmatterTools reads both the inline comma list and the YAML block
+    // list (#5790).
+    const claudeTools = parseFrontmatterTools(frontmatter);
     const mappedTools = claudeTools.map(t => convertCopilotToolName(t));
     const uniqueTools = [...new Set(mappedTools)];
     const toolsArray = uniqueTools.length > 0
@@ -3187,7 +3188,9 @@ function convertClaudeAgentToCodexAgent(content) {
         return converted;
     const name = extractFrontmatterField(frontmatter, 'name') || 'unknown';
     const description = extractFrontmatterField(frontmatter, 'description') || '';
-    const tools = extractFrontmatterField(frontmatter, 'tools') || '';
+    // parseFrontmatterTools reads both the inline comma list and the YAML block
+    // list (#5790).
+    const tools = parseFrontmatterTools(frontmatter).join(', ');
     const roleHeader = `<codex_agent_role>
 role: ${name}
 tools: ${tools}

package/gsd-core/bin/lib/runtime-artifact-install-plan.cjs

@@ -11,6 +11,7 @@ const _require = require;
 const path = _require('node:path');
 const { tryWithinRootLexical } = _require('./security.cjs');
 const { hostBehaviorsFor } = _require('./runtime-name-policy.cjs');
+const { isMinimalMode } = _require('./install-profiles.cjs');
 // #2870: InstallScope is owned by install-scope.cts, not re-declared here.
 // `isGlobalScope` centralizes the `scope === 'global'` boolean projection
 // this module needs at `_computePathPrefix`'s `isGlobal: boolean` boundary
@@ -49,6 +50,64 @@ function assertDestWithinConfigHome(configDir, destSubpath) {
     }
     return contained;
 }
+function resolveRuntimeArtifactDestination(configDir, kind) {
+    return assertDestWithinConfigHome(resolveRuntimeArtifactInstallRoot(configDir, kind), kind.destSubpath);
+}
+function resolveRuntimeArtifactInstallRoot(configDir, kind) {
+    if (kind?.home != null && typeof kind.home !== 'string') {
+        throw new TypeError('Artifact home must be a string, null, or undefined');
+    }
+    return (kind && typeof kind.home === 'string' && kind.home !== '') ? kind.home : configDir;
+}
+function shouldInstallCombinedFamily(behaviors) {
+    return Boolean(behaviors.combinedFamilyInstall);
+}
+function isLegacyFlatLocalInstall(behaviors, scope) {
+    return scope === 'local' && behaviors.localInstallStyle === 'legacy-flat';
+}
+function shouldInstallStandaloneAgents(pluginOnlyInstall, skillsRuntime) {
+    return !pluginOnlyInstall && !skillsRuntime;
+}
+function requiredRuntimeSurfaceSources(layout, scope) {
+    const required = new Set();
+    if (!(0, install_scope_cjs_1.isGlobalScope)(scope))
+        return required;
+    for (const kind of layout.kinds) {
+        if (kind.kind === 'commands' || kind.kind === 'skills')
+            required.add('commands');
+        if (kind.kind === 'agents' || kind.kind === 'kimi-agents')
+            required.add('agents');
+    }
+    return required;
+}
+function codexAgentRolesEnabled(installMode, resolvedProfile) {
+    return !isMinimalMode(installMode) || (resolvedProfile.agents instanceof Set && resolvedProfile.agents.size > 0);
+}
+function plannedActionsMutateCodexHooksInputs(actions) {
+    return actions.some((action) => (action.relPath === 'hooks.json' || action.relPath === 'config.toml') &&
+        ['rewrite-json', 'remove-managed', 'backup-and-remove'].includes(action.type));
+}
+function copyWithPathReplacementSymlinkRefusalMessage(destDir, installRoot) {
+    return `copyWithPathReplacement: destDir "${destDir}" contains a symlink the install root "${installRoot}" does not trust \u2014 refusing to write. If this is an intentional user-owned symlink layout, re-run with GSD_ALLOW_SYMLINKED_DEST=1.`;
+}
+function installRuntimeArtifactsSymlinkRefusalMessage(dest, installRoot) {
+    return `installRuntimeArtifacts: destDir "${dest}" contains a symlink the install root "${installRoot}" does not trust \u2014 refusing to create. If this is an intentional user-owned symlink layout (e.g. externalized skills/hooks dir, multi-account configHome, or a dotfiles-managed configHome), re-run with GSD_ALLOW_SYMLINKED_DEST=1.`;
+}
+function installOpencodeFamilySkillsSymlinkRefusalMessage(dest, installRoot) {
+    return `installOpencodeFamilySkills: destDir "${dest}" contains a symlink the install root "${installRoot}" does not trust \u2014 refusing to write. If this is an intentional user-owned symlink layout, re-run with GSD_ALLOW_SYMLINKED_DEST=1.`;
+}
+function installAgentsKindStandaloneSymlinkRefusalMessage(dest, installRoot) {
+    return `installAgentsKindStandalone: destDir "${dest}" contains a symlink the install root "${installRoot}" does not trust \u2014 refusing to write. If this is an intentional user-owned symlink layout, re-run with GSD_ALLOW_SYMLINKED_DEST=1.`;
+}
+function syncRuntimeSurfaceCorpusSymlinkRefusalMessage(destination, installRoot) {
+    return `syncRuntimeSurfaceCorpus: destination "${destination}" contains a symlink the install root "${installRoot}" does not trust \u2014 refusing to write.`;
+}
+function installCodexConfigSymlinkRefusalMessage(targetDir) {
+    return `installCodexConfig: a Codex config path under "${targetDir}" contains a symlink the install root does not trust \u2014 refusing to write. If this is an intentional user-owned symlink layout, re-run with GSD_ALLOW_SYMLINKED_DEST=1.`;
+}
+function installCodexAgentTomlSymlinkRefusalMessage(agentTomlPath) {
+    return `installCodexConfig: agent toml path "${agentTomlPath}" contains a symlink the install root does not trust \u2014 refusing to write. If this is an intentional user-owned symlink layout, re-run with GSD_ALLOW_SYMLINKED_DEST=1.`;
+}
 function errorMessage(err) {
     if (err instanceof Error)
         return err.message;
@@ -135,7 +194,7 @@ function createRuntimeArtifactInstallPlan(args) {
         items.push({
             kind: kind.kind,
             sourceDir,
-            destDir: assertDestWithinConfigHome(kind.home ?? layout.configDir, kind.destSubpath),
+            destDir: resolveRuntimeArtifactDestination(layout.configDir, kind),
         });
     }
     return { ok: true, plan: { items, cleanupDirs } };
@@ -144,8 +203,27 @@ function createRuntimeArtifactUninstallPlan(layout) {
     return {
         items: layout.kinds.map((kind) => ({
             kind: kind.kind,
-            destDir: assertDestWithinConfigHome(kind.home ?? layout.configDir, kind.destSubpath),
+            destDir: resolveRuntimeArtifactDestination(layout.configDir, kind),
         })),
     };
 }
-module.exports = { assertDestWithinConfigHome, createRuntimeArtifactInstallPlan, createRuntimeArtifactUninstallPlan };
+module.exports = {
+    assertDestWithinConfigHome,
+    resolveRuntimeArtifactDestination,
+    resolveRuntimeArtifactInstallRoot,
+    shouldInstallCombinedFamily,
+    isLegacyFlatLocalInstall,
+    shouldInstallStandaloneAgents,
+    requiredRuntimeSurfaceSources,
+    codexAgentRolesEnabled,
+    plannedActionsMutateCodexHooksInputs,
+    copyWithPathReplacementSymlinkRefusalMessage,
+    installRuntimeArtifactsSymlinkRefusalMessage,
+    installOpencodeFamilySkillsSymlinkRefusalMessage,
+    installAgentsKindStandaloneSymlinkRefusalMessage,
+    syncRuntimeSurfaceCorpusSymlinkRefusalMessage,
+    installCodexConfigSymlinkRefusalMessage,
+    installCodexAgentTomlSymlinkRefusalMessage,
+    createRuntimeArtifactInstallPlan,
+    createRuntimeArtifactUninstallPlan,
+};

package/gsd-core/bin/lib/runtime-hooks-surface.cjs

@@ -31,6 +31,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_os_1 = __importDefault(require("node:os"));
+const runtime_name_policy_cjs_1 = require("./runtime-name-policy.cjs");
 // #2544: the single source of truth for the CommonJS module-type marker. The
 // two helpers below are thin boolean-returning shims over these — see the
 // marker section for why this file no longer carries its own copy.
@@ -615,6 +616,182 @@ function resolveBashRunner(opts) {
         ? JSON.stringify(executable)
         : executable;
 }
+// ---------------------------------------------------------------------------
+// #5850 — PowerShell hook runner (Claude Code on Windows)
+// ---------------------------------------------------------------------------
+/**
+ * #5850 (owner ruling: always PowerShell on win32): every managed JS hook command
+ * Claude gets on Windows is a PowerShell command carrying an explicit
+ * `shell: "powershell"` (see projectPowerShellHookShell), whether or not Git Bash
+ * is discoverable. The POSIX `$(for ... done)` runner chain does not parse when
+ * Claude Code hosts the hook in PowerShell, and a blocking PreToolUse guard that
+ * cannot start blocks every tool call. An explicit `hookShell: 'bash'` still
+ * selects the chain (a test/projection seam, never set by the installer).
+ */
+function usesPowerShellHookShell(opts) {
+    if (opts && opts.hookShell === 'bash')
+        return false;
+    const platform = (opts && opts.platform) || process.platform;
+    const runtime = (opts && opts.runtime) || 'generic';
+    return platform === 'win32' && (0, runtime_name_policy_cjs_1.hostBehaviorsFor)(runtime).powershellHooksOnWindows === true;
+}
+/**
+ * A PowerShell single-quoted string literal. PowerShell treats U+2018..U+201B
+ * as single-quote delimiters as well as the ASCII quote, and each is escaped by
+ * doubling itself.
+ */
+function powerShellQuote(value) {
+    return `'${value.replace(/['\u2018\u2019\u201A\u201B]/g, (q) => q + q)}'`;
+}
+/**
+ * A hook script path as a PowerShell argument. A path anchored on
+ * `"$CLAUDE_PROJECT_DIR"/...` (local installs) or `$HOME/...` (portable installs)
+ * becomes an expanding PowerShell expression; any other path is a single-quoted
+ * literal. A path carrying some OTHER shell variable (`$FOO`) is a POSIX token
+ * with no PowerShell spelling here: null, and the caller leaves the entry alone.
+ */
+function powerShellScriptArg(scriptPath, opts = {}) {
+    const projectDir = scriptPath.match(/^"\$CLAUDE_PROJECT_DIR"(\/.*)$/);
+    const homeDir = scriptPath.match(/^\$HOME(\/.*)$/);
+    const anchored = projectDir || homeDir;
+    if (anchored) {
+        const variable = projectDir ? '$env:CLAUDE_PROJECT_DIR' : '$HOME';
+        const suffix = anchored[1];
+        // Plain suffixes keep the readable double-quoted expansion; any character
+        // PowerShell treats specially inside double quotes (including the curly
+        // double quotes) moves the suffix into a single-quoted literal.
+        if (!/["`$\u201C\u201D\u201E]/.test(suffix))
+            return `"${variable}${suffix}"`;
+        return `(${variable} + ${powerShellQuote(suffix)})`;
+    }
+    // A real filesystem path (the installer's own configDir) may contain `$`; a
+    // token read back from settings.json may not (it would never expand).
+    if (!opts.literal && scriptPath.includes('$'))
+        return null;
+    return powerShellQuote(shellCmdProjection.posixNormalize(scriptPath));
+}
+/**
+ * The PowerShell counterpart of buildNodeRunnerChainToken: the baked install-time
+ * node first (the minimal-PATH guarantee), then node on PATH, resolved when the
+ * hook fires. `scriptToken` is an already-quoted PowerShell argument.
+ */
+function buildPowerShellHookCommand(scriptToken, opts) {
+    const execPath = (opts && opts.execPath) || (typeof process.execPath === 'string' ? process.execPath : '');
+    if (!execPath)
+        return null;
+    const baked = powerShellQuote(shellCmdProjection.posixNormalize(normalizeNodePath(execPath, opts)));
+    // The `exit` tail: `powershell -Command` collapses a native exit code to 0/1
+    // unless the script exits with it, and a blocking guard denies with exit 2. A
+    // runner that never started leaves $LASTEXITCODE null and exits 1, not 0.
+    return `& ((@(${baked}) + @(Get-Command node -CommandType Application -ErrorAction SilentlyContinue | Where-Object { $_.Source -like '*.exe' } | ForEach-Object { $_.Source })) | Where-Object { $_ -and (Test-Path -LiteralPath $_) } | Select-Object -First 1) ${scriptToken}; exit $(if ($null -ne $LASTEXITCODE) { $LASTEXITCODE } else { 1 })`;
+}
+/**
+ * Local installs anchor the script under `"$CLAUDE_PROJECT_DIR"/<dir>`; the
+ * PowerShell spelling of that variable is `$env:CLAUDE_PROJECT_DIR`.
+ */
+function buildPowerShellLocalHookCommand(opts) {
+    if (!opts.localPrefix || !opts.hookFile)
+        return null;
+    const arg = powerShellScriptArg(`${opts.localPrefix}/hooks/${opts.hookFile}`);
+    return arg === null ? null : buildPowerShellHookCommand(arg, opts);
+}
+/**
+ * The statusLine spelling. Claude Code runs a statusLine command through Git Bash
+ * when it is installed and through PowerShell when it is not, and a statusLine has
+ * no `shell` key to pin that. One command line that both hosts run is
+ * `powershell -NoProfile -Command "..."` with a body free of `$`, backticks and
+ * backslashes (all special inside bash double quotes). null when a path carries
+ * one of those, so the statusLine is skipped rather than written broken.
+ */
+function buildPowerShellStatusLineCommand(scriptPath, opts) {
+    const execPath = (opts && opts.execPath) || (typeof process.execPath === 'string' ? process.execPath : '');
+    if (!execPath)
+        return null;
+    const baked = shellCmdProjection.posixNormalize(normalizeNodePath(execPath, opts));
+    const script = shellCmdProjection.posixNormalize(scriptPath);
+    if ([baked, script].some((p) => /["`$\\]/.test(p)))
+        return null;
+    const b = powerShellQuote(baked);
+    const sc = powerShellQuote(script);
+    return `powershell -NoProfile -Command "if (Test-Path -LiteralPath ${b}) { & ${b} ${sc} } else { & node ${sc} }"`;
+}
+const POWERSHELL_STATUSLINE_COMMAND = /^powershell -NoProfile -Command "if \(Test-Path -LiteralPath '(?:[^']|'')*'\) \{ & '(?:[^']|'')*' '((?:[^']|'')*)' \} else \{ & node '((?:[^']|'')*)' \}"$/;
+function unquotePowerShell(value) {
+    return value.replace(/(['\u2018\u2019\u201A\u201B])\1/g, '$1');
+}
+/**
+ * Read the script back out of a PowerShell runner or statusLine command, as the
+ * POSIX path/token pair projectLegacySettingsHookCommand takes. null when the
+ * command is not one of GSD's PowerShell shapes.
+ */
+function parsePowerShellScript(command) {
+    // A path bash would expand or re-quote (`$`, backtick, `"`) has no faithful POSIX
+    // spelling here: refuse, and the entry stays as written. (A portable install under
+    // a directory named with one of them therefore stays PowerShell on a POSIX host.)
+    const posixUnsafe = /["`$]/;
+    const status = command.match(POWERSHELL_STATUSLINE_COMMAND);
+    if (status) {
+        const scriptPath = unquotePowerShell(status[2]);
+        return posixUnsafe.test(scriptPath) ? null : { scriptPath, scriptToken: JSON.stringify(scriptPath) };
+    }
+    const runner = command.replace(/^&\s+/, '').trim().match(/^\(\(@\('(?:[^']|'')*'\) \+ @\(Get-Command node [\s\S]*?Select-Object -First 1\)\s+(.+?); exit \$\(if [\s\S]*\)$/);
+    if (!runner)
+        return null;
+    const arg = runner[1];
+    let m = arg.match(/^'((?:[^']|'')*)'$/);
+    if (m) {
+        const scriptPath = unquotePowerShell(m[1]);
+        return posixUnsafe.test(scriptPath) ? null : { scriptPath, scriptToken: JSON.stringify(scriptPath) };
+    }
+    m = arg.match(/^"\$env:CLAUDE_PROJECT_DIR(\/[^"]*)"$/) || arg.match(/^\(\$env:CLAUDE_PROJECT_DIR \+ '((?:[^']|'')*)'\)$/);
+    if (m) {
+        const rel = unquotePowerShell(m[1]);
+        if (posixUnsafe.test(rel))
+            return null;
+        const token = `"$CLAUDE_PROJECT_DIR"${rel}`;
+        return { scriptPath: token, scriptToken: token };
+    }
+    m = arg.match(/^"\$HOME(\/[^"]*)"$/) || arg.match(/^\(\$HOME \+ '((?:[^']|'')*)'\)$/);
+    if (m) {
+        const rel = unquotePowerShell(m[1]);
+        if (posixUnsafe.test(rel))
+            return null;
+        return { scriptPath: `$HOME${rel}`, scriptToken: `"$HOME${rel}"` };
+    }
+    return null;
+}
+// Recognizes buildPowerShellHookCommand's output once the `& ` call operator is stripped.
+const POWERSHELL_RUNNER_COMMAND = /^\(\(@\('(?:[^']|'')*'\) \+ @\(Get-Command node [\s\S]*?Select-Object -First 1\)\s+\S/;
+function isPowerShellRunnerCommand(command) {
+    return typeof command === 'string' && /^&\s+/.test(command) && POWERSHELL_RUNNER_COMMAND.test(command.replace(/^&\s+/, '').trim());
+}
+/**
+ * Set the explicit `shell: "powershell"` on every hook whose command is the
+ * PowerShell runner, so Claude Code does not depend on its own Git Bash
+ * detection to pick the shell. Returns true when a hook changed. Idempotent.
+ */
+function projectPowerShellHookShell(settings) {
+    if (!settings || !settings.hooks)
+        return false;
+    let changed = false;
+    for (const entries of Object.values(settings.hooks)) {
+        if (!Array.isArray(entries))
+            continue;
+        for (const entry of entries) {
+            if (!entry || !Array.isArray(entry.hooks))
+                continue;
+            for (const h of entry.hooks) {
+                if (!h || !isPowerShellRunnerCommand(h.command) || !isManagedHookCommand(h.command, { surface: 'settings-json' }))
+                    continue;
+                if (h.shell === 'powershell')
+                    continue;
+                h.shell = 'powershell';
+                changed = true;
+            }
+        }
+    }
+    return changed;
+}
 // #3662 — recognize the two runtime-resolving command shapes the installer
 // emits, so the rewriter never churns (or un-does) an entry that already
 // works in every environment sharing the config root.
@@ -626,8 +803,31 @@ function rewriteLegacyManagedNodeHookCommands(settings, runnerToken, opts) {
     if (!opts)
         opts = {};
     const platform = opts.platform || process.platform;
+    const usePowerShell = usesPowerShellHookShell({ platform, runtime: opts.runtime });
     let changed = false;
-    for (const entries of Object.values(settings.hooks)) {
+    // #5850: the managed statusLine is a command like a hook. It is converted to the
+    // shell-neutral PowerShell spelling on the PowerShell path, and back to the POSIX
+    // chain when a PowerShell statusLine reaches a POSIX host (shared config root).
+    const statusLine = settings.statusLine;
+    const statusLineGroups = statusLine && typeof statusLine.command === 'string'
+        && (usePowerShell || POWERSHELL_STATUSLINE_COMMAND.test(statusLine.command))
+        ? [{ hooks: [statusLine] }]
+        : [];
+    const toPowerShell = (h, scriptPath) => (h === statusLine
+        ? buildPowerShellStatusLineCommand(scriptPath, opts)
+        : (() => {
+            const arg = powerShellScriptArg(scriptPath);
+            return arg === null ? null : buildPowerShellHookCommand(arg, opts);
+        })());
+    const assign = (h, command) => {
+        if (!command || h.command === command)
+            return;
+        h.command = command;
+        if (h.shell === 'powershell' && !usePowerShell)
+            delete h.shell;
+        changed = true;
+    };
+    for (const entries of [...Object.values(settings.hooks), statusLineGroups]) {
         if (!Array.isArray(entries))
             continue;
         for (const entry of entries) {
@@ -638,12 +838,53 @@ function rewriteLegacyManagedNodeHookCommands(settings, runnerToken, opts) {
                     continue;
                 if (Array.isArray(h.args) && h.args.length > 0)
                     continue;
+                if (!usePowerShell && platform !== 'win32') {
+                    // #5850: a PowerShell entry on a POSIX host (a config root shared with
+                    // Windows) is a syntax error in bash; converge it back to the POSIX chain.
+                    const ps = parsePowerShellScript(h.command);
+                    if (ps) {
+                        if (!isManagedHookBasename(ps.scriptPath, { surface: 'settings-json' }))
+                            continue;
+                        assign(h, projectLegacySettingsHookCommand({
+                            runnerToken,
+                            scriptPath: ps.scriptPath,
+                            scriptToken: ps.scriptToken,
+                            runtime: opts.runtime || 'generic',
+                            platform,
+                        }));
+                        continue;
+                    }
+                }
                 let trimmed = h.command.trim();
                 const hadPowerShellCallOperator = platform === 'win32' && /^&\s+/.test(trimmed);
                 if (hadPowerShellCallOperator) {
                     trimmed = trimmed.replace(/^&\s+/, '').trim();
                 }
-                if (CHAIN_RUNNER_COMMAND.test(trimmed) || RESOLVER_RUNNER_COMMAND.test(trimmed))
+                if (usePowerShell) {
+                    // #5850: already the PowerShell runner: nothing to do. A POSIX chain
+                    // (or a legacy bare/foreign-node entry) is re-projected below.
+                    if (POWERSHELL_RUNNER_COMMAND.test(trimmed) || POWERSHELL_STATUSLINE_COMMAND.test(trimmed))
+                        continue;
+                    const chain = trimmed.match(/^"\$\(for n in [\s\S]*?printf '%s' "\$n" && break; done\)"\s+(?:"([^"]+)"|'([^']+)'|(\S+))\s*$/);
+                    if (chain) {
+                        const chainScript = chain[1] || chain[2] || chain[3] || '';
+                        if (!isManagedHookBasename(chainScript, { surface: 'settings-json' }))
+                            continue;
+                        assign(h, toPowerShell(h, chainScript));
+                        continue;
+                    }
+                    // The #3662 bash resolver shape needs bash too; its script is a plain
+                    // or `$HOME`-relative path, both spelled for PowerShell.
+                    const resolver = trimmed.match(/^(?:"[^"]*bash(?:\.exe)?"|bash)\s+"[^"]*gsd-node-runner\.sh"\s+"[^"]*"\s+(?:"([^"]+)"|(\S+))\s*$/);
+                    if (resolver) {
+                        const resolverScript = resolver[1] || resolver[2] || '';
+                        if (!isManagedHookBasename(resolverScript, { surface: 'settings-json' }))
+                            continue;
+                        assign(h, toPowerShell(h, resolverScript));
+                        continue;
+                    }
+                }
+                if (CHAIN_RUNNER_COMMAND.test(trimmed) || RESOLVER_RUNNER_COMMAND.test(trimmed) || POWERSHELL_RUNNER_COMMAND.test(trimmed))
                     continue;
                 const m = trimmed.match(/^node\s+("([^"]+)"|'([^']+)'|(\S+))\s*$/) ||
                     trimmed.match(/^("([^"]+)"|'([^']+)'|(\S+))\s+("([^"]+)"|'([^']+)'|(\S+))\s*$/);
@@ -666,6 +907,10 @@ function rewriteLegacyManagedNodeHookCommands(settings, runnerToken, opts) {
                 }
                 if (!isManagedHookBasename(scriptPath, { surface: 'settings-json' }))
                     continue;
+                if (usePowerShell) {
+                    assign(h, toPowerShell(h, scriptPath));
+                    continue;
+                }
                 const projectedCommand = projectLegacySettingsHookCommand({
                     runnerToken,
                     scriptPath,
@@ -831,12 +1076,9 @@ function _installEngineSymlinkGuard() {
     const mod = require('./install-engine.cjs');
     return mod;
 }
-function reconcileCodexHooksJsonEvent(targetDir, eventName, opts = {}) {
+// Shared by install preflight and the hooks writer; resolving never writes.
+function resolveCodexHooksJsonDestination(targetDir) {
     const hooksJsonPath = node_path_1.default.join(targetDir, 'hooks.json');
-    const managedCommand = typeof opts.managedCommand === 'string' ? opts.managedCommand : null;
-    const commandWindows = typeof opts.commandWindows === 'string' ? opts.commandWindows : null;
-    const matcher = typeof opts.matcher === 'string' ? opts.matcher : undefined;
-    const timeout = typeof opts.timeout === 'number' ? opts.timeout : undefined;
     // #2586 Major 2: every Codex hooks.json writer funnels through this one
     // function, and atomicWriteFileSync's final step is a rename(2) onto
     // `hooksJsonPath` — which, when that path is a symlink, REPLACES the
@@ -868,6 +1110,15 @@ function reconcileCodexHooksJsonEvent(targetDir, eventName, opts = {}) {
         // is supposed to mean.
         effectiveHooksJsonPath = node_fs_1.default.realpathSync(hooksJsonPath);
     }
+    return effectiveHooksJsonPath;
+}
+function reconcileCodexHooksJsonEvent(targetDir, eventName, opts = {}) {
+    const hooksJsonPath = node_path_1.default.join(targetDir, 'hooks.json');
+    const managedCommand = typeof opts.managedCommand === 'string' ? opts.managedCommand : null;
+    const commandWindows = typeof opts.commandWindows === 'string' ? opts.commandWindows : null;
+    const matcher = typeof opts.matcher === 'string' ? opts.matcher : undefined;
+    const timeout = typeof opts.timeout === 'number' ? opts.timeout : undefined;
+    const effectiveHooksJsonPath = resolveCodexHooksJsonDestination(targetDir);
     let parsed = {};
     let currentContent = null;
     if (node_fs_1.default.existsSync(effectiveHooksJsonPath)) {
@@ -1280,7 +1531,8 @@ function configuredEntrypointsForHook(configDir, hookName, opts) {
         '/usr/local/bin/node',
         '/usr/bin/node',
     ].filter((candidate) => Boolean(candidate));
-    if (!opts.portableHooks) {
+    // #5850: the PowerShell runner needs no bash resolver, portable or not.
+    if (!opts.portableHooks || usesPowerShellHookShell({ platform, runtime, hookShell: opts.hookShell })) {
         return [{ ...target, interpreterCandidates: nodeCandidates }];
     }
     const runner = {
@@ -1363,6 +1615,20 @@ function buildHookCommand(configDir, hookName, opts) {
     // baked as a bare absolute path — an install-environment absolute path is
     // exactly what breaks with exit 127 when the config root is shared across
     // environments with different node layouts.
+    // #5850: Claude on win32 always gets the PowerShell runner (owner ruling),
+    // portable installs included: the `$HOME`-relative script path is spelled for
+    // PowerShell and needs no bash resolver.
+    if (usesPowerShellHookShell({ platform, runtime, hookShell })) {
+        const scriptPath = opts.portableHooks
+            ? `${projectPortableHookBaseDir({ configDir, homeDir: node_os_1.default.homedir() })}/hooks/${hookName}`
+            : shellCmdProjection.posixNormalize(configDir) + '/hooks/' + hookName;
+        // A statusLine is not shared across hosts and has no `$`-free `$HOME` spelling:
+        // it always carries the real absolute path, portable or not.
+        if (opts.statusLine) {
+            return track(buildPowerShellStatusLineCommand(shellCmdProjection.posixNormalize(configDir) + '/hooks/' + hookName, opts));
+        }
+        return track(buildPowerShellHookCommand(powerShellScriptArg(scriptPath, { literal: true }), opts));
+    }
     if (opts.portableHooks) {
         // Portable installs route through the staged resolver: the baked absolute
         // path travels as the resolver's FIRST argument (tried first, so the
@@ -2852,6 +3118,7 @@ module.exports = {
     writeCopilotHookConfig,
     GSD_COPILOT_HOOK_FILE,
     // Codex hooks.json
+    resolveCodexHooksJsonDestination,
     reconcileCodexHooksJsonEvent,
     reconcileCodexHooksJsonSessionStart,
     ensureCodexHooksJsonSessionStart,
@@ -2892,6 +3159,10 @@ module.exports = {
     normalizeNodePath,
     resolveNodeRunner,
     buildNodeRunnerChainToken,
+    usesPowerShellHookShell,
+    buildPowerShellHookCommand,
+    buildPowerShellLocalHookCommand,
+    projectPowerShellHookShell,
     resolveBashExecutable,
     resolveBashRunner,
     NODE_RUNNER_RESOLVER_HOOK,

package/gsd-core/bin/lib/runtime-slash.cjs

@@ -40,6 +40,9 @@ exports.runtimeCommand = runtimeCommand;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const runtime_name_policy_cjs_1 = require("./runtime-name-policy.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- config-file-read.cjs is an export= CommonJS module
+const configFileReadMod = require("./config-file-read.cjs");
+const { readConfigFileBounded } = configFileReadMod;
 function formatGsdSlash(commandName, runtime) {
     if (typeof commandName !== 'string')
         return commandName;
@@ -171,9 +174,11 @@ function readProjectConfig(projectDir) {
         return null;
     try {
         const configPath = node_path_1.default.join(projectDir, '.planning', 'config.json');
-        if (!node_fs_1.default.existsSync(configPath))
+        // Bounded read (#5759): null is an absent file; a FIFO/device/oversized one throws and degrades to null.
+        const raw = readConfigFileBounded(configPath);
+        if (raw === null)
             return null;
-        const parsed = JSON.parse(node_fs_1.default.readFileSync(configPath, 'utf-8'));
+        const parsed = JSON.parse(raw);
         return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
     }
     catch {