@opengsd/gsd-core 1.7.0-rc.2 → 1.7.0-rc.4

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

@@ -54,6 +54,9 @@ const { checkAgentsInstalled } = agentInstallCheck;
 const gitBaseBranch = require("./git-base-branch.cjs");
 const { gitWorktreeInfoInternal } = gitBaseBranch;
 const resolution_cjs_1 = require("./resolution.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- onboard-projection.cjs is an export= CommonJS module
+const onboardProjection = require("./onboard-projection.cjs");
+const { REQUIRED_CODEBASE_MAP_FILES, buildOnboardProjection, hasCodeFilesInternal, hasPackageFileInternal, listCodebaseMapFiles, } = onboardProjection;
 const { output, error } = io;
 const { loadConfig, loadConfigResolved } = configLoader;
 const { resolveModelInternal, resolveGranularityInternal, assertValidGranularityOverride } = modelResolver;
@@ -479,84 +482,23 @@ function cmdInitNewProject(cwd, raw) {
     const hasFirecrawl = !!(process.env['FIRECRAWL_API_KEY'] || node_fs_1.default.existsSync(firecrawlKeyFile));
     const exaKeyFile = node_path_1.default.join(homedir, '.gsd', 'exa_api_key');
     const hasExaSearch = !!(process.env['EXA_API_KEY'] || node_fs_1.default.existsSync(exaKeyFile));
-    let hasCode = false;
-    let hasPackageFile = false;
-    try {
-        const codeExtensions = new Set([
-            '.ts', '.js', '.py', '.go', '.rs', '.swift', '.java',
-            '.kt', '.kts',
-            '.c', '.cpp', '.h',
-            '.cs',
-            '.rb',
-            '.php',
-            '.dart',
-            '.m', '.mm',
-            '.scala',
-            '.groovy',
-            '.lua',
-            '.r', '.R',
-            '.zig',
-            '.ex', '.exs',
-            '.clj',
-        ]);
-        const skipDirs = new Set([
-            'node_modules', '.git', '.planning', '.claude', '.codex',
-            '__pycache__', 'target', 'dist', 'build',
-        ]);
-        function findCodeFiles(dir, depth) {
-            if (depth > 3)
-                return false;
-            let entries;
-            try {
-                entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
-            }
-            catch {
-                return false;
-            }
-            for (const entry of entries) {
-                if (entry.isFile() && codeExtensions.has(node_path_1.default.extname(entry.name)))
-                    return true;
-                if (entry.isDirectory() && !skipDirs.has(entry.name)) {
-                    if (findCodeFiles(node_path_1.default.join(dir, entry.name), depth + 1))
-                        return true;
-                }
-            }
-            return false;
-        }
-        hasCode = findCodeFiles(cwd, 0);
-    }
-    catch {
-        /* intentionally empty — best-effort detection */
-    }
-    hasPackageFile =
-        pathExistsInternal(cwd, 'package.json') ||
-            pathExistsInternal(cwd, 'requirements.txt') ||
-            pathExistsInternal(cwd, 'Cargo.toml') ||
-            pathExistsInternal(cwd, 'go.mod') ||
-            pathExistsInternal(cwd, 'Package.swift') ||
-            pathExistsInternal(cwd, 'build.gradle') ||
-            pathExistsInternal(cwd, 'build.gradle.kts') ||
-            pathExistsInternal(cwd, 'pom.xml') ||
-            pathExistsInternal(cwd, 'Gemfile') ||
-            pathExistsInternal(cwd, 'composer.json') ||
-            pathExistsInternal(cwd, 'pubspec.yaml') ||
-            pathExistsInternal(cwd, 'CMakeLists.txt') ||
-            pathExistsInternal(cwd, 'Makefile') ||
-            pathExistsInternal(cwd, 'build.zig') ||
-            pathExistsInternal(cwd, 'mix.exs') ||
-            pathExistsInternal(cwd, 'project.clj');
+    const hasCode = hasCodeFilesInternal(cwd);
+    const hasPackageFile = hasPackageFileInternal(cwd);
+    const isBrownfield = hasCode || hasPackageFile;
+    const codebaseMapFiles = listCodebaseMapFiles(cwd);
+    const hasCodebaseMap = codebaseMapFiles.length === REQUIRED_CODEBASE_MAP_FILES.length;
     const result = {
         researcher_model: resolveModelInternal(cwd, 'gsd-project-researcher'),
         synthesizer_model: resolveModelInternal(cwd, 'gsd-research-synthesizer'),
         roadmapper_model: resolveModelInternal(cwd, 'gsd-roadmapper'),
         commit_docs: config.commit_docs,
         project_exists: pathExistsInternal(cwd, '.planning/PROJECT.md'),
-        has_codebase_map: pathExistsInternal(cwd, '.planning/codebase'),
+        has_codebase_map: hasCodebaseMap,
         planning_exists: pathExistsInternal(cwd, '.planning'),
         has_existing_code: hasCode,
         has_package_file: hasPackageFile,
-        is_brownfield: hasCode || hasPackageFile,
-        needs_codebase_map: (hasCode || hasPackageFile) && !pathExistsInternal(cwd, '.planning/codebase'),
+        is_brownfield: isBrownfield,
+        needs_codebase_map: isBrownfield && !hasCodebaseMap,
         ...getInitGitState(cwd),
         brave_search_available: hasBraveSearch,
         firecrawl_available: hasFirecrawl,
@@ -656,6 +598,19 @@ function cmdInitIngestDocs(cwd, raw) {
     };
     output(withProjectRoot(cwd, result), raw);
 }
+function cmdInitOnboard(cwd, raw, options = {}) {
+    const config = loadConfig(cwd);
+    const workflowConfig = (config.workflow ?? {});
+    const result = {
+        ...buildOnboardProjection(cwd, {
+            commitDocs: !!config.commit_docs,
+            fast: options['fast'] === true,
+            textMode: options['text'] === true || !!config.text_mode || !!workflowConfig['text_mode'],
+        }),
+        ...getInitGitState(cwd),
+    };
+    output(withProjectRoot(cwd, result), raw);
+}
 function cmdInitResume(cwd, raw) {
     const config = loadConfig(cwd);
     let interruptedAgentId = null;
@@ -2099,6 +2054,7 @@ module.exports = {
     cmdInitNewMilestone,
     cmdInitQuick,
     cmdInitIngestDocs,
+    cmdInitOnboard,
     cmdInitResume,
     cmdInitVerifyWork,
     cmdInitPhaseOp,

package/gsd-core/bin/lib/install-engine.cjs

@@ -222,7 +222,7 @@ function migrateLegacyDevPreferencesToSkill(targetDir, saved, runtime, scope = '
  *   - agents: write as-is (files already carry their own `gsd-` prefix).
  * For kimi-agents kind: recursively copy generated YAML/prompt files.
  */
-function _copyStaged(stagedDir, destDir, kind, configDir) {
+function _copyStaged(stagedDir, destDir, kind, configDir, runtime) {
     // Defense-in-depth: verify destDir is within the install root even if the
     // upstream assertDestWithinConfigHome check was somehow bypassed. This guards
     // the actual write site against any future call-site drift.
@@ -275,8 +275,11 @@ function _copyStaged(stagedDir, destDir, kind, configDir) {
         const stem = entry.name.slice(0, -3); // strip .md
         let destName;
         if (kind.kind === 'agents') {
-            // Agent files already carry the gsd- prefix in the source dir
-            destName = entry.name;
+            // Agent files already carry the gsd- prefix in the source dir.
+            // #1575: copilot agents get .agent.md suffix (mirrors inline loop line ~9118).
+            destName = runtime === 'copilot'
+                ? entry.name.replace(/\.md$/, '.agent.md')
+                : entry.name;
         }
         else if (namespacedByDir) {
             // Directory is the namespace; don't double-prefix the filename
@@ -571,7 +574,7 @@ function installRuntimeArtifacts(runtime, configDir, scope, resolvedProfile, res
                     }
                 }
                 _removeGsdEntries(dest, kind);
-                _copyStaged(item.sourceDir, dest, kind, configDir);
+                _copyStaged(item.sourceDir, dest, kind, configDir, runtime);
                 // Restore user-owned dirs after the prune+copy
                 for (const [dirName, snap] of toPreserve) {
                     _restoreDir(node_path_1.default.join(dest, dirName), snap);
@@ -581,7 +584,7 @@ function installRuntimeArtifacts(runtime, configDir, scope, resolvedProfile, res
                 // For non-skills kinds (commands, agents): no user content to preserve;
                 // just prune stale gsd-* entries and copy new ones.
                 _removeGsdEntries(dest, kind);
-                _copyStaged(item.sourceDir, dest, kind, configDir);
+                _copyStaged(item.sourceDir, dest, kind, configDir, runtime);
             }
         }
     }

package/gsd-core/bin/lib/install-profiles.cjs

@@ -42,6 +42,7 @@ const PROFILES = Object.freeze({
     standard: Object.freeze([
         // Core loop
         'new-project',
+        'onboard',
         'discuss-phase',
         'plan-phase',
         'execute-phase',
@@ -819,6 +820,7 @@ module.exports = {
     writeActiveProfile,
     // Shared internals
     parseRequires,
+    parseCallsAgents,
     cleanupStagedSkills,
     // Back-compat / deprecated
     MINIMAL_SKILL_ALLOWLIST,

package/gsd-core/bin/lib/loop-resolver.cjs

@@ -415,6 +415,12 @@ function cmdLoopRenderHooks(cwd, point, raw, options = {}) {
     const runtimeConfigDir = typeof options['configDir'] === 'string'
         ? options['configDir']
         : undefined;
+    // #2003: thread an explicit --runtime override into the capability-state
+    // resolver so the config-dir resolution bypasses the persisted-runtime
+    // fallback (GSD_RUNTIME → config.runtime). Without this, a repo with persisted
+    // runtime:"codex" resolves the config dir to ~/.codex and execute:post /
+    // verify:post hooks silently no-op when the operator drives from Claude Code.
+    const runtimeOverride = typeof options['runtime'] === 'string' ? options['runtime'] : undefined;
     // Load the config snapshot ONCE and share it with both the capability-state
     // resolver (via configOverride) and loop-hook resolution, so federated keys
     // present in loadConfig resolve identically for `active` and for hook when/
@@ -429,7 +435,7 @@ function cmdLoopRenderHooks(cwd, point, raw, options = {}) {
     catch {
         config = {};
     }
-    const state = resolveCapabilityRuntimeState(cwd, runtimeConfigDir, config);
+    const state = resolveCapabilityRuntimeState(cwd, runtimeConfigDir, config, runtimeOverride);
     // Load overlay-aware registry (ADR-1244 D2 wiring) so installed third-party
     // capabilities are visible to loop rendering exactly like first-party ones.
     // eslint-disable-next-line @typescript-eslint/no-require-imports

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

@@ -263,7 +263,13 @@ function cmdMilestoneComplete(cwd, version, options, raw) {
     // Archive REQUIREMENTS.md
     if (node_fs_1.default.existsSync(reqPath)) {
         const reqContent = node_fs_1.default.readFileSync(reqPath, 'utf-8');
-        const archiveHeader = `# Requirements Archive: ${version} ${milestoneName}\n\n**Archived:** ${today}\n**Status:** SHIPPED\n\nFor current requirements, see \`.planning/REQUIREMENTS.md\`.\n\n---\n\n`;
+        // Derive the display path from the same source the writer uses (reqPath), so a
+        // workstream archive header points at `.planning/workstreams/<ws>/REQUIREMENTS.md`
+        // instead of the hardcoded root path (#1993). Root case is byte-identical.
+        // Normalize to POSIX separators so the header is cross-platform (Windows
+        // path.relative yields backslashes; the original literal was forward-slash).
+        const reqDisplay = node_path_1.default.relative(cwd, reqPath).split(node_path_1.default.sep).join('/');
+        const archiveHeader = `# Requirements Archive: ${version} ${milestoneName}\n\n**Archived:** ${today}\n**Status:** SHIPPED\n\nFor current requirements, see \`${reqDisplay}\`.\n\n---\n\n`;
         (0, shell_command_projection_cjs_1.platformWriteSync)(node_path_1.default.join(archiveDir, `${version}-REQUIREMENTS.md`), archiveHeader + reqContent);
     }
     // Archive audit file if exists

package/gsd-core/bin/lib/model-resolver.cjs

@@ -78,6 +78,61 @@ function warnModelPolicyUnmappable(agentType, policyModel, tier) {
 function _resetModelPolicyWarningCacheForTests() {
     _modelPolicyUnmappableWarned.clear();
 }
+// Dedupe stderr warnings for unmappable model_overrides Claude IDs (#2041).
+const _modelOverrideUnmappableWarned = new Set();
+function warnModelOverrideUnmappable(agentType, overrideValue) {
+    const key = `${agentType}::${overrideValue}`;
+    if (_modelOverrideUnmappableWarned.has(key))
+        return;
+    _modelOverrideUnmappableWarned.add(key);
+    // Cap emission length so an oversized or secret-shaped value cannot leak in
+    // full to stderr/logs (#2041 security review). MUST go to stderr — resolve-
+    // model's JSON result is parsed from stdout.
+    const safe = overrideValue.length > 64 ? overrideValue.slice(0, 64) + '…' : overrideValue;
+    process.stderr.write(`gsd: warning — model_overrides value "${safe}" for ${agentType} ` +
+        `has no Claude agent alias; falling through to tier resolution.\n`);
+}
+// Test-only: reset the model_overrides warn-dedupe cache between cases (#2041).
+function _resetModelOverrideWarningCacheForTests() {
+    _modelOverrideUnmappableWarned.clear();
+}
+/**
+ * #2041 — Map a `model_overrides` value to its Claude Agent-tool alias on the
+ * claude runtime, mirroring the `model_policy` path (#1144). Claude Code's
+ * Agent tool `model` parameter documents only tier aliases (opus/sonnet/haiku/
+ * fable); a full Claude model ID returned verbatim is silently dropped by the
+ * spawner. Returns the value to return verbatim, or null to signal "fall
+ * through to normal tier/dynamic-routing resolution" (used when a Claude full
+ * ID has no alias — matches model_policy's warn-and-fall-through). Non-Claude
+ * runtimes and non-Claude values always pass through verbatim.
+ *
+ * Hardening (code+security review): a `typeof` guard preserves the pre-fix
+ * no-crash behavior if a malformed config surfaces a non-string value, and an
+ * `Object.hasOwn` lookup defeats `__proto__`/`constructor` lookups on the plain
+ * object literal so those reserved keys cannot return a truthy non-string.
+ */
+function mapClaudeOverrideForRuntime(override, configRuntime, agentType) {
+    // Defensive: model_overrides is typed Record<string,string> but a malformed
+    // config could surface a non-string; pass through verbatim (preserving the
+    // pre-fix no-crash behaviour) and let the downstream Agent tool reject it.
+    if (typeof override !== 'string')
+        return override;
+    const onClaude = !configRuntime || configRuntime === 'claude';
+    if (!onClaude)
+        return override;
+    // Object.hasOwn guards against __proto__/constructor returning a truthy
+    // non-string from the plain object literal (#2041 security review).
+    if (Object.hasOwn(CLAUDE_POLICY_ID_TO_ALIAS, override)) {
+        return CLAUDE_POLICY_ID_TO_ALIAS[override];
+    }
+    if (CLAUDE_AGENT_ALIASES.has(override))
+        return override;
+    if (override.startsWith('claude-')) {
+        warnModelOverrideUnmappable(agentType, override);
+        return null;
+    }
+    return override;
+}
 /**
  * #49 — Provider-neutral model policy preset resolution.
  */
@@ -134,11 +189,16 @@ function resolveModelPolicy(policy, tier) {
 }
 function resolveModelInternal(cwd, agentType) {
     const config = loadConfig(cwd);
-    // 1. Per-agent override
+    // 1. Per-agent override (#2041: map Claude full IDs → Agent-tool aliases on
+    // the claude runtime, mirroring the model_policy path #1144; non-Claude
+    // runtimes and non-Claude values pass through verbatim).
     const modelOverrides = config['model_overrides'];
     const override = modelOverrides?.[agentType];
     if (override) {
-        return override;
+        const mapped = mapClaudeOverrideForRuntime(override, config['runtime'], agentType);
+        if (mapped !== null)
+            return mapped;
+        // Unmappable Claude ID — fall through to tier resolution (matches model_policy).
     }
     // 2. Compute the tier
     // eslint-disable-next-line @typescript-eslint/no-base-to-string
@@ -252,8 +312,12 @@ function resolveModelForTier(cwd, agentType, attempt) {
     const attemptN = Number.isInteger(attempt) && attempt > 0 ? attempt : 0;
     const modelOverrides = config['model_overrides'];
     const override = modelOverrides?.[agentType];
-    if (override)
-        return override;
+    if (override) {
+        const mapped = mapClaudeOverrideForRuntime(override, config['runtime'], agentType);
+        if (mapped !== null)
+            return mapped;
+        // Unmappable Claude ID — fall through to dynamic_routing / model_policy resolution.
+    }
     if (config['model_policy'] && config['runtime'] && config['runtime'] !== 'claude') {
         return resolveModelInternal(cwd, agentType);
     }
@@ -454,6 +518,7 @@ module.exports = {
     resolveModelPolicy,
     resolveModelInternal,
     _resetModelPolicyWarningCacheForTests,
+    _resetModelOverrideWarningCacheForTests,
     VALID_GRANULARITIES,
     resolveGranularityInternal,
     assertValidGranularityOverride,

package/gsd-core/bin/lib/onboard-projection.cjs

@@ -0,0 +1,309 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- core-utils.cjs is an export= CommonJS module
+const coreUtils = require("./core-utils.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- planning-workspace.cjs is an export= CommonJS module
+const planningWorkspace = require("./planning-workspace.cjs");
+const runtime_slash_cjs_1 = require("./runtime-slash.cjs");
+const { pathExistsInternal, toPosixPath } = coreUtils;
+const { planningDir, planningRoot } = planningWorkspace;
+const CODE_EXTENSIONS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.py', '.go', '.rs', '.swift', '.java',
+    '.kt', '.kts', '.c', '.cpp', '.cc', '.h', '.hpp', '.cs', '.rb', '.php', '.dart',
+    '.m', '.mm', '.scala', '.groovy', '.lua', '.r', '.R', '.zig', '.ex', '.exs', '.clj',
+]);
+const CODE_SCAN_SKIP_DIRS = new Set([
+    'node_modules', '.git', '.planning', '.claude', '.codex', '__pycache__', 'target',
+    'dist', 'build', '.next', '.nuxt', '.svelte-kit', 'coverage', 'vendor', '.venv', 'venv',
+]);
+const PACKAGE_FILES = [
+    'package.json', 'requirements.txt', 'pyproject.toml', 'Cargo.toml', 'go.mod',
+    'Package.swift', 'build.gradle', 'build.gradle.kts', 'pom.xml', 'Gemfile',
+    'composer.json', 'pubspec.yaml', 'CMakeLists.txt', 'Makefile', 'build.zig',
+    'mix.exs', 'project.clj',
+];
+const REQUIRED_CODEBASE_MAP_FILES = [
+    'STACK.md', 'ARCHITECTURE.md', 'STRUCTURE.md', 'CONVENTIONS.md', 'TESTING.md',
+    'INTEGRATIONS.md', 'CONCERNS.md',
+];
+const FAST_CODEBASE_MAP_FILES = [
+    'STACK.md', 'INTEGRATIONS.md', 'ARCHITECTURE.md', 'STRUCTURE.md',
+];
+const PLANNING_DOC_SEGMENTS = new Set([
+    'adr', 'adrs', 'prd', 'prds', 'spec', 'specs', 'rfc', 'rfcs',
+]);
+function hasCodeFilesInternal(dir, depth = 0) {
+    if (depth > 3)
+        return false;
+    let entries;
+    try {
+        entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return false;
+    }
+    for (const entry of entries) {
+        if (entry.isFile() && CODE_EXTENSIONS.has(node_path_1.default.extname(entry.name)))
+            return true;
+        if (entry.isDirectory() && !CODE_SCAN_SKIP_DIRS.has(entry.name)) {
+            if (hasCodeFilesInternal(node_path_1.default.join(dir, entry.name), depth + 1))
+                return true;
+        }
+    }
+    return false;
+}
+function hasPackageFileInternal(cwd) {
+    return PACKAGE_FILES.some((file) => pathExistsInternal(cwd, file));
+}
+function listPlanningDocCandidates(cwd) {
+    const roots = ['docs', 'adr', 'adrs', 'prd', 'prds', 'spec', 'specs', 'rfc', 'rfcs'];
+    const candidates = new Set();
+    function isPlanningDocCandidate(rel, name) {
+        const upperName = name.toUpperCase();
+        const relLower = rel.toLowerCase();
+        const pathSegments = relLower.split('/');
+        return (/(^|[-_ ])(ADR|PRD|SPEC|RFC)([-_ ]|\.)/i.test(name) ||
+            /^\d{4}[-_].+\.md$/i.test(name) ||
+            pathSegments.some((segment) => PLANNING_DOC_SEGMENTS.has(segment)) ||
+            upperName === 'REQUIREMENTS.MD');
+    }
+    function addCandidate(rel, name) {
+        if (name.toLowerCase().endsWith('.md') && isPlanningDocCandidate(rel, name)) {
+            candidates.add(toPosixPath(rel));
+        }
+    }
+    function visit(dir, relDir, depth) {
+        if (depth > 3)
+            return;
+        let entries;
+        try {
+            entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const rel = relDir ? `${relDir}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                if (!CODE_SCAN_SKIP_DIRS.has(entry.name)) {
+                    visit(node_path_1.default.join(dir, entry.name), rel, depth + 1);
+                }
+                continue;
+            }
+            if (entry.isFile())
+                addCandidate(rel, entry.name);
+        }
+    }
+    let rootEntries = [];
+    try {
+        rootEntries = node_fs_1.default.readdirSync(cwd, { withFileTypes: true });
+    }
+    catch {
+        rootEntries = [];
+    }
+    for (const entry of rootEntries) {
+        if (entry.isFile())
+            addCandidate(entry.name, entry.name);
+    }
+    for (const root of roots) {
+        const full = node_path_1.default.join(cwd, root);
+        if (node_fs_1.default.existsSync(full))
+            visit(full, root, 0);
+    }
+    return [...candidates].sort();
+}
+function listCodebaseMapFiles(cwd) {
+    const codebaseDir = node_path_1.default.join(planningRoot(cwd), 'codebase');
+    if (!node_fs_1.default.existsSync(codebaseDir))
+        return [];
+    return REQUIRED_CODEBASE_MAP_FILES.filter((file) => node_fs_1.default.existsSync(node_path_1.default.join(codebaseDir, file)));
+}
+function getMapReadiness(hasCompleteMap, hasFastMap) {
+    if (hasCompleteMap)
+        return 'complete';
+    if (hasFastMap)
+        return 'fast';
+    return 'none';
+}
+function mapSummaryStatus(mapReadiness) {
+    if (mapReadiness === 'complete')
+        return '.planning/codebase/ (complete codebase map)';
+    if (mapReadiness === 'fast')
+        return '.planning/codebase/ (fast/partial codebase map; complete map still required for project setup)';
+    return 'missing';
+}
+function mapFinalStatus(mapReadiness) {
+    if (mapReadiness === 'complete')
+        return 'complete';
+    if (mapReadiness === 'fast')
+        return 'fast/partial; complete map still required for project setup';
+    return 'missing';
+}
+function planningMissing(projectExists, requirementsExists, roadmapExists, stateExists) {
+    const missing = [];
+    if (!projectExists)
+        missing.push('PROJECT.md');
+    if (!requirementsExists)
+        missing.push('REQUIREMENTS.md');
+    if (!roadmapExists)
+        missing.push('ROADMAP.md');
+    if (!stateExists)
+        missing.push('STATE.md');
+    return missing;
+}
+function nextAction(params) {
+    if (params.isBrownfield && params.needsOnboardCodebaseMap) {
+        return {
+            kind: 'map-codebase',
+            command: params.fastMode ? params.handoffCommands.map_codebase_fast : params.handoffCommands.map_codebase,
+            reason: 'Existing code was detected, but the required .planning/codebase/ map is missing.',
+        };
+    }
+    if (params.hasPlanningArtifacts && params.missingPlanningFiles.length > 0) {
+        return {
+            kind: 'partial-planning',
+            missing: params.missingPlanningFiles,
+            reason: 'Project planning exists but required planning files are missing.',
+        };
+    }
+    if (params.fastMode && params.mapReadiness === 'fast' && !params.projectExists) {
+        return {
+            kind: 'complete-map-before-new-project',
+            command: params.handoffCommands.map_codebase,
+            reason: 'The fast map is enough for lightweight onboarding, but project setup still requires the complete codebase map.',
+        };
+    }
+    if (params.hasDocsCandidates && !params.projectExists) {
+        return {
+            kind: 'ingest-docs',
+            command: params.handoffCommands.ingest_docs,
+            reason: 'Detected existing ADR/PRD/SPEC/RFC document(s) before project setup.',
+        };
+    }
+    if (!params.isBrownfield && !params.projectExists && !params.hasDocsCandidates) {
+        return {
+            kind: 'new-project',
+            command: params.handoffCommands.new_project,
+            reason: 'No existing code or planning docs were detected.',
+        };
+    }
+    if (!params.projectExists) {
+        return {
+            kind: 'new-project',
+            command: params.handoffCommands.new_project,
+            reason: 'Codebase context is ready for project initialization.',
+        };
+    }
+    if (!params.onboardingSummaryExists) {
+        return {
+            kind: 'write-summary',
+            summary_path: params.onboardingSummaryPath,
+            reason: 'Onboarding summary is missing.',
+        };
+    }
+    return {
+        kind: 'ready',
+        reason: 'Onboarding summary already exists.',
+    };
+}
+function buildHandoffCommands(cwd) {
+    const runtime = (0, runtime_slash_cjs_1.resolveRuntime)(cwd);
+    return {
+        ingest_docs: (0, runtime_slash_cjs_1.formatGsdSlash)('ingest-docs', runtime),
+        manager: (0, runtime_slash_cjs_1.formatGsdSlash)('manager', runtime),
+        map_codebase: (0, runtime_slash_cjs_1.formatGsdSlash)('map-codebase', runtime),
+        map_codebase_fast: (0, runtime_slash_cjs_1.formatGsdSlash)('map-codebase --fast', runtime),
+        new_project: (0, runtime_slash_cjs_1.formatGsdSlash)('new-project', runtime),
+        onboard: (0, runtime_slash_cjs_1.formatGsdSlash)('onboard', runtime),
+    };
+}
+function buildOnboardProjection(cwd, options) {
+    const handoffCommands = buildHandoffCommands(cwd);
+    const codebaseMapFiles = listCodebaseMapFiles(cwd);
+    const missingCodebaseMapFiles = REQUIRED_CODEBASE_MAP_FILES.filter((file) => !codebaseMapFiles.includes(file));
+    const missingFastCodebaseMapFiles = FAST_CODEBASE_MAP_FILES.filter((file) => !codebaseMapFiles.includes(file));
+    const docCandidates = listPlanningDocCandidates(cwd);
+    const hasCode = hasCodeFilesInternal(cwd);
+    const hasPackageFile = hasPackageFileInternal(cwd);
+    const isBrownfield = hasCode || hasPackageFile;
+    const hasCodebaseMap = codebaseMapFiles.length === REQUIRED_CODEBASE_MAP_FILES.length;
+    const hasFastCodebaseMap = missingFastCodebaseMapFiles.length === 0;
+    const mapReadinessValue = getMapReadiness(hasCodebaseMap, hasFastCodebaseMap);
+    const needsCodebaseMap = isBrownfield && !hasCodebaseMap;
+    const needsFastCodebaseMap = isBrownfield && !hasFastCodebaseMap;
+    const needsOnboardCodebaseMap = options.fast ? needsFastCodebaseMap : needsCodebaseMap;
+    const projectRootPath = node_path_1.default.join(planningRoot(cwd), 'PROJECT.md');
+    const projectScopedPath = node_path_1.default.join(planningDir(cwd), 'PROJECT.md');
+    const projectExists = node_fs_1.default.existsSync(projectRootPath) || node_fs_1.default.existsSync(projectScopedPath);
+    const requirementsExists = node_fs_1.default.existsSync(node_path_1.default.join(planningDir(cwd), 'REQUIREMENTS.md'));
+    const roadmapExists = node_fs_1.default.existsSync(node_path_1.default.join(planningDir(cwd), 'ROADMAP.md'));
+    const stateExists = node_fs_1.default.existsSync(node_path_1.default.join(planningDir(cwd), 'STATE.md'));
+    const onboardingSummaryPath = node_path_1.default.join(planningRoot(cwd), 'onboarding', 'SUMMARY.md');
+    const onboardingSummaryExists = node_fs_1.default.existsSync(onboardingSummaryPath);
+    const hasPlanningArtifacts = projectExists || requirementsExists || roadmapExists || stateExists;
+    const missingPlanningFiles = planningMissing(projectExists, requirementsExists, roadmapExists, stateExists);
+    return {
+        commit_docs: options.commitDocs,
+        text_mode: options.textMode,
+        project_exists: projectExists,
+        planning_exists: node_fs_1.default.existsSync(planningRoot(cwd)),
+        requirements_exists: requirementsExists,
+        roadmap_exists: roadmapExists,
+        state_exists: stateExists,
+        config_exists: node_fs_1.default.existsSync(node_path_1.default.join(planningDir(cwd), 'config.json')),
+        handoff_commands: handoffCommands,
+        has_existing_code: hasCode,
+        has_package_file: hasPackageFile,
+        is_brownfield: isBrownfield,
+        fast_mode: options.fast,
+        map_readiness: mapReadinessValue,
+        next_action: nextAction({
+            fastMode: options.fast,
+            isBrownfield,
+            needsOnboardCodebaseMap,
+            hasDocsCandidates: docCandidates.length > 0,
+            projectExists,
+            mapReadiness: mapReadinessValue,
+            onboardingSummaryExists,
+            onboardingSummaryPath: toPosixPath(node_path_1.default.relative(cwd, onboardingSummaryPath)),
+            hasPlanningArtifacts,
+            missingPlanningFiles,
+            handoffCommands,
+        }),
+        needs_codebase_map: needsCodebaseMap,
+        needs_fast_codebase_map: needsFastCodebaseMap,
+        has_codebase_map: hasCodebaseMap,
+        has_fast_codebase_map: hasFastCodebaseMap,
+        codebase_dir_exists: node_fs_1.default.existsSync(node_path_1.default.join(planningRoot(cwd), 'codebase')),
+        fast_codebase_map_files_required: FAST_CODEBASE_MAP_FILES,
+        codebase_map_files_present: codebaseMapFiles,
+        missing_codebase_map_files: missingCodebaseMapFiles,
+        missing_fast_codebase_map_files: missingFastCodebaseMapFiles,
+        codebase_map_summary_status: mapSummaryStatus(mapReadinessValue),
+        codebase_map_final_status: mapFinalStatus(mapReadinessValue),
+        has_docs_candidates: docCandidates.length > 0,
+        doc_candidate_count: docCandidates.length,
+        doc_candidates: docCandidates,
+        onboarding_summary_exists: onboardingSummaryExists,
+        onboarding_summary_path: toPosixPath(node_path_1.default.relative(cwd, onboardingSummaryPath)),
+        project_path: toPosixPath(node_path_1.default.relative(cwd, node_fs_1.default.existsSync(projectRootPath) ? projectRootPath : projectScopedPath)),
+        requirements_path: toPosixPath(node_path_1.default.relative(cwd, node_path_1.default.join(planningDir(cwd), 'REQUIREMENTS.md'))),
+        roadmap_path: toPosixPath(node_path_1.default.relative(cwd, node_path_1.default.join(planningDir(cwd), 'ROADMAP.md'))),
+        state_path: toPosixPath(node_path_1.default.relative(cwd, node_path_1.default.join(planningDir(cwd), 'STATE.md'))),
+        codebase_dir: toPosixPath(node_path_1.default.relative(cwd, node_path_1.default.join(planningRoot(cwd), 'codebase'))),
+        onboarding_dir: toPosixPath(node_path_1.default.relative(cwd, node_path_1.default.join(planningRoot(cwd), 'onboarding'))),
+    };
+}
+module.exports = {
+    REQUIRED_CODEBASE_MAP_FILES,
+    FAST_CODEBASE_MAP_FILES,
+    buildOnboardProjection,
+    hasCodeFilesInternal,
+    hasPackageFileInternal,
+    listCodebaseMapFiles,
+    listPlanningDocCandidates,
+};