@opengsd/gsd-core 1.5.0 → 1.6.0-rc.2

package/gsd-core/bin/lib/capability-writer.cjs

@@ -24,7 +24,13 @@
  */
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const ioMod = require("./io.cjs");
-const { output: coreOutput, error: coreError } = ioMod;
+const { output: coreOutput } = ioMod;
+// ExitError (NOT process.exit) is how every gsd-tools command signals a non-zero exit: runMain
+// translates it to process.exitCode so buffered stdout flushes first. Calling process.exit() here
+// truncates a just-written --raw JSON payload before the reader sees it (a real silent-output bug).
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const cliExitMod = require("./cli-exit.cjs");
+const { ExitError } = cliExitMod;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const capabilityStateMod = require("./capability-state.cjs");
 const { resolveCapabilityRuntimeState, _resolveManifest, _resolveCommandsGsdDir } = capabilityStateMod;
@@ -322,7 +328,8 @@ function cmdCapabilitySet(cwd, runtimeConfigDir, capId, options, raw) {
         // Do NOT print human stderr lines — raw consumers parse the JSON.
         coreOutput({ capabilities: result.capabilities, warnings: result.warnings, errors: result.errors }, true);
         if (result.errors.length > 0) {
-            process.exit(1);
+            // Throw (don't process.exit) so the JSON written just above flushes before the process ends.
+            throw new ExitError(1);
         }
         return;
     }
@@ -333,10 +340,12 @@ function cmdCapabilitySet(cwd, runtimeConfigDir, capId, options, raw) {
     for (const e of result.errors) {
         process.stderr.write(`capability set: error: ${e}\n`);
     }
-    // Exit non-zero if any errors (hard failures — requested action was not realized).
+    // Exit non-zero if any errors (hard failures — requested action was not realized). The per-error
+    // lines were already written to stderr above; signal the exit code via ExitError (not process.exit)
+    // so any pending stdout/stderr flushes — runMain maps it to process.exitCode.
     if (result.errors.length > 0) {
-        coreError(`capability set: ${String(result.errors.length)} error(s) — see above`);
-        return; // unreachable — coreError calls process.exit(1)
+        process.stderr.write(`Error: capability set: ${String(result.errors.length)} error(s) — see above\n`);
+        throw new ExitError(1);
     }
     // Human-readable summary: focus on the target capability
     const cap = result.capabilities.find((c) => c.id === capId);

package/gsd-core/bin/lib/check-command-router.cjs

@@ -22,6 +22,7 @@ const { planningDir } = planningWorkspaceMod;
 const phaseLocatorMod = require("./phase-locator.cjs");
 const { findPhaseInternal } = phaseLocatorMod;
 const decisions_cjs_1 = require("./decisions.cjs");
+const markdown_sectionizer_cjs_1 = require("./markdown-sectionizer.cjs");
 const ui_safety_gate_cjs_1 = require("./ui-safety-gate.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const verifyModule = require("./verify.cjs");
@@ -128,10 +129,11 @@ function loadPlanContents(phaseDir) {
 const DESIGNATED_HEADINGS_RE = /^#{1,6}\s+(?:must[_ ]haves?|truths?|tasks?|objective)\b/i;
 const XML_DECISION_TAGS_RE = /<(?:objective|tasks?|action)(?:\s[^>]*)?>([\s\S]*?)<\/(?:objective|tasks?|action)>/gi;
 function stripCommentsAndFences(text) {
-    return text
-        .replace(/<!--[\s\S]*?-->/g, ' ')
-        .replace(/```[\s\S]*?```/g, ' ')
-        .replace(/~~~[\s\S]*?~~~/g, ' ');
+    // HTML-comment stripping stays caller-side (the seam does not strip HTML comments).
+    const htmlStripped = text.replace(/<!--[\s\S]*?-->/g, ' ');
+    // Fenced-code stripping: delegate to the canonical CommonMark-correct seam.
+    // replaces the prior independent regex copy (```` ``` ``` ````  + `~~~ ~~~`).
+    return (0, markdown_sectionizer_cjs_1.stripFencedCode)(htmlStripped).text;
 }
 function extractYamlBlock(frontmatter, key) {
     const match = frontmatter.match(new RegExp(`^${key}\\s*:(.*)$`, 'm'));
@@ -169,18 +171,19 @@ function extractPlanDesignatedSections(planContent) {
         if (block)
             parts.push(block);
     }
+    // Replace hand-rolled split(/\r?\n/) + heading walk with the seam's collectSections.
+    // stopPredicate fires on EVERY heading (collectSections needs to start a section at
+    // each heading), then we filter to designated ones — same semantics as the prior
+    // inDesignated flag: emit the heading line + body only when DESIGNATED_HEADINGS_RE matches.
+    const sections = (0, markdown_sectionizer_cjs_1.collectSections)(body, () => true);
     const bodyParts = [];
-    let inDesignated = false;
-    for (const line of body.split(/\r?\n/)) {
-        const heading = /^#{1,6}\s+/.test(line);
-        if (heading) {
-            inDesignated = DESIGNATED_HEADINGS_RE.test(line);
-            if (inDesignated)
-                bodyParts.push(line);
-            continue;
+    for (const section of sections) {
+        const headingLine = '#'.repeat(section.heading.level) + ' ' + section.heading.text;
+        if (DESIGNATED_HEADINGS_RE.test(headingLine)) {
+            bodyParts.push(headingLine);
+            if (section.body)
+                bodyParts.push(section.body);
         }
-        if (inDesignated)
-            bodyParts.push(line);
     }
     parts.push(bodyParts.join('\n'));
     parts.push(extractXmlTagBodies(cleaned));
@@ -213,8 +216,12 @@ function buildVerifyMessage(notHonored) {
         'This is a soft warning - verification status is unchanged.',
     ].join('\n');
 }
-function loadTrackableDecisions(contextPath) {
-    return (0, decisions_cjs_1.parseDecisions)(readIfExists(contextPath)).filter((decision) => decision.trackable);
+function loadDecisionExtraction(contextPath) {
+    const extraction = (0, decisions_cjs_1.extractDecisions)(readIfExists(contextPath));
+    return {
+        trackable: extraction.decisions.filter((d) => d.trackable),
+        outcome: extraction.outcome,
+    };
 }
 function cmdDecisionCoveragePlan(projectDir, args, raw) {
     const phaseDir = args[2] ? resolvePath(args[2], projectDir) : '';
@@ -227,7 +234,31 @@ function cmdDecisionCoveragePlan(projectDir, args, raw) {
         output({ passed: true, skipped: true, reason: 'CONTEXT.md missing', total: 0, covered: 0, uncovered: [], message: 'No CONTEXT.md - nothing to check.' }, raw, undefined);
         return;
     }
-    const decisions = loadTrackableDecisions(contextPath);
+    const { trackable: decisions, outcome } = loadDecisionExtraction(contextPath);
+    // #1365 fail-loud gate: any could-not-parse outcome must NOT silently pass —
+    // even when some decisions were extracted (e.g. D-01 valid but D-02 malformed).
+    // A parse-miss on ANY bullet means the gate cannot certify full coverage.
+    // Fire independent of decisions.length so a partial-parse still blocks.
+    if (outcome === 'could-not-parse') {
+        const partialParse = decisions.length > 0;
+        output({
+            passed: false,
+            skipped: false,
+            reason: 'could-not-parse',
+            total: decisions.length,
+            covered: 0,
+            uncovered: [],
+            message: partialParse
+                ? 'Decision coverage gate: decisions could not be fully parsed — one or more ' +
+                    '`- **D-NN ...**` bullets appear malformed (missing `:` or ` — ` separator). ' +
+                    'Fix the bullet format so all D-NN decisions can be read before re-running the gate.'
+                : 'Decision coverage gate: could not parse decisions — possible format mismatch. ' +
+                    'The CONTEXT.md appears to be decision-shaped (has a <decisions> block, a decisions heading, ' +
+                    'or D- tokens) but no D-NN bullets could be extracted. Check the formatting of the decisions ' +
+                    'block and ensure bullets follow the `- **D-NN:** text` or `- **D-NN — title** body` form.',
+        }, raw, undefined);
+        return;
+    }
     if (decisions.length === 0) {
         output({ passed: true, skipped: true, reason: 'no trackable decisions', total: 0, covered: 0, uncovered: [], message: 'No trackable decisions in CONTEXT.md.' }, raw, undefined);
         return;
@@ -305,7 +336,27 @@ function cmdDecisionCoverageVerify(projectDir, args, raw) {
         output({ skipped: true, blocking: false, reason: 'CONTEXT.md missing', total: 0, honored: 0, not_honored: [], message: 'No CONTEXT.md - nothing to check.' }, raw, undefined);
         return;
     }
-    const decisions = loadTrackableDecisions(contextPath);
+    const { trackable: decisions, outcome: decisionOutcome } = loadDecisionExtraction(contextPath);
+    // Mirror could-not-parse surface for verify (non-blocking advisory WARN).
+    // Fire independent of decisions.length — a parse-miss on any bullet must surface,
+    // even when some decisions were partially extracted (#1365 fix-parity with plan gate).
+    if (decisionOutcome === 'could-not-parse') {
+        const partialParse = decisions.length > 0;
+        output({
+            skipped: false,
+            blocking: false,
+            reason: 'could-not-parse',
+            total: decisions.length,
+            honored: 0,
+            not_honored: [],
+            message: partialParse
+                ? 'Decision coverage verify (warning): decisions could not be fully parsed — one or more ' +
+                    '`- **D-NN ...**` bullets appear malformed. Fix the bullet format in the CONTEXT.md decisions block.'
+                : 'Decision coverage verify (warning): could not parse decisions — possible format mismatch. ' +
+                    'Check the formatting of the CONTEXT.md decisions block.',
+        }, raw, undefined);
+        return;
+    }
     if (decisions.length === 0) {
         output({ skipped: true, blocking: false, reason: 'no trackable decisions', total: 0, honored: 0, not_honored: [], message: 'No trackable decisions in CONTEXT.md.' }, raw, undefined);
         return;

package/gsd-core/bin/lib/command-aliases.cjs

@@ -444,6 +444,14 @@ exports.PHASE_COMMAND_ALIASES = [
         ],
         "subcommand": "scaffold",
         "mutation": true
+    },
+    {
+        "canonical": "phase.list-plans",
+        "aliases": [
+            "phase list-plans"
+        ],
+        "subcommand": "list-plans",
+        "mutation": false
     }
 ];
 exports.PHASES_COMMAND_ALIASES = [

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

@@ -12,6 +12,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 shell_command_projection_cjs_1 = require("./shell-command-projection.cjs");
+const security_cjs_1 = require("./security.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const ioMod = require("./io.cjs");
 const { output, error } = ioMod;
@@ -144,6 +145,110 @@ function cmdListTodos(cwd, area, raw) {
     const result = { count, todos };
     output(result, raw, count.toString());
 }
+/**
+ * List captured seeds from .planning/seeds/SEED-*.md for browsing/audit (#441).
+ *
+ * Unlike audit.scanSeeds (which returns only *unimplemented* seeds for the
+ * milestone surface), this lists seeds of every status with the richer fields a
+ * human audit needs (scope, trigger, planted date). An optional case-insensitive
+ * status filter narrows the set. Seed content is user-controlled, so every
+ * displayed field is passed through sanitizeForDisplay and each file path is
+ * validated with requireSafePath before reading. Read-only — never mutates.
+ */
+/**
+ * Derive the canonical `{ seed_id, slug }` from a seed filename stem and the
+ * frontmatter `id:` value. Pure (no I/O) so it can be property-tested directly.
+ *
+ * seed_id: frontmatter `id:` when it matches `SEED-NNN`, else the numeric prefix
+ * of the filename (`SEED-NNN-…`), else the whole stem. slug: the descriptive
+ * remainder after `SEED-NNN-`, else the stem with a leading `SEED-` stripped.
+ * `rawFmId` is `unknown` because frontmatter values are not guaranteed strings.
+ */
+function deriveSeedIdentity(stem, rawFmId) {
+    const fmId = typeof rawFmId === 'string' ? rawFmId.trim() : '';
+    let seedId;
+    if (/^SEED-\d+$/i.test(fmId)) {
+        seedId = fmId;
+    }
+    else {
+        const numMatch = stem.match(/^(SEED-\d+)/i);
+        seedId = numMatch ? numMatch[1] : stem;
+    }
+    const slugMatch = stem.match(/^SEED-\d+-(.+)$/i);
+    const slug = slugMatch ? slugMatch[1] : stem.replace(/^SEED-/i, '');
+    return { seed_id: seedId, slug };
+}
+function cmdListSeeds(cwd, statusFilter, raw) {
+    const planDir = planningDir(cwd);
+    const seedsDir = node_path_1.default.join(planDir, 'seeds');
+    const wantStatus = statusFilter ? statusFilter.trim().toLowerCase() : null;
+    const seeds = [];
+    const summary = {};
+    // Frontmatter values are not guaranteed to be scalars: extractFrontmatter
+    // yields {} for a bare `key:` line and an array for `key: [a, b]`. Coerce every
+    // read to a string so one malformed seed cannot crash the whole audit list
+    // (`.toLowerCase()` on a non-string throws) or leak a raw object/array into the
+    // JSON contract. Mirrors the existing `typeof fm.id === 'string'` guard below.
+    const fmStr = (v) => (typeof v === 'string' ? v : '');
+    let files;
+    try {
+        files = node_fs_1.default.readdirSync(seedsDir, { withFileTypes: true });
+    }
+    catch {
+        // No seeds dir (or unreadable) — an empty, non-error result. The seed dir is
+        // created lazily by the first plant-seed, so absence is the normal zero case.
+        output({ count: 0, seeds: [], summary: {} }, raw, '0');
+        return;
+    }
+    for (const entry of files) {
+        if (!entry.isFile())
+            continue;
+        if (!entry.name.startsWith('SEED-') || !entry.name.endsWith('.md'))
+            continue;
+        let safeFilePath;
+        try {
+            safeFilePath = (0, security_cjs_1.requireSafePath)(node_path_1.default.join(seedsDir, entry.name), planDir, 'seed file', { allowAbsolute: true });
+        }
+        catch {
+            continue;
+        }
+        const content = (0, shell_command_projection_cjs_1.platformReadSync)(safeFilePath);
+        if (content === null)
+            continue;
+        const fm = extractFrontmatter(content);
+        const status = (fmStr(fm.status) || 'dormant').toLowerCase().trim() || 'dormant';
+        // Match on the raw lowercased status (both sides already normalized);
+        // sanitizeForDisplay is for output, not comparison.
+        if (wantStatus && status !== wantStatus)
+            continue;
+        // Canonical seed id is `SEED-NNN` (frontmatter `id:`, e.g. SEED-001). Fall
+        // back to the numeric prefix of the filename, then to the whole stem. The
+        // descriptive remainder of the filename (`SEED-NNN-<slug>.md`) is the slug.
+        const stem = node_path_1.default.basename(entry.name, '.md');
+        const { seed_id: seedId, slug } = deriveSeedIdentity(stem, fm.id);
+        let title = (0, security_cjs_1.sanitizeForDisplay)(fmStr(fm.title).slice(0, 100));
+        if (!title) {
+            const headingMatch = content.match(/^#\s*(.+)$/m);
+            if (headingMatch)
+                title = (0, security_cjs_1.sanitizeForDisplay)(headingMatch[1].trim().slice(0, 100));
+        }
+        const safeStatus = (0, security_cjs_1.sanitizeForDisplay)(status);
+        summary[safeStatus] = (summary[safeStatus] || 0) + 1;
+        seeds.push({
+            seed_id: (0, security_cjs_1.sanitizeForDisplay)(seedId),
+            slug: (0, security_cjs_1.sanitizeForDisplay)(slug),
+            status: safeStatus,
+            scope: (0, security_cjs_1.sanitizeForDisplay)(fmStr(fm.scope) || 'unknown'),
+            trigger_when: (0, security_cjs_1.sanitizeForDisplay)(fmStr(fm.trigger_when)),
+            planted: (0, security_cjs_1.sanitizeForDisplay)(fmStr(fm.planted)),
+            title,
+            path: toPosixPath(node_path_1.default.relative(cwd, safeFilePath)),
+        });
+    }
+    // Stable order: by seed_id so output is deterministic across filesystems.
+    seeds.sort((a, b) => a.seed_id.localeCompare(b.seed_id));
+    output({ count: seeds.length, seeds, summary }, raw, seeds.length.toString());
+}
 function cmdVerifyPathExists(cwd, targetPath, raw) {
     if (!targetPath) {
         error('path required for verification');
@@ -629,6 +734,145 @@ function cmdCommitToSubrepo(cwd, message, files, raw) {
     };
     output(result, raw, Object.entries(repos).map(([r, v]) => `${r}:${v.hash || 'skip'}`).join(' '));
 }
+/**
+ * Prepare a sub-repo for a companion PR branch.
+ *
+ * Detects uncommitted changes, creates a new branch, stages every changed
+ * file explicitly (never git add -A per universal-anti-patterns.md:44), commits,
+ * and pushes with --set-upstream. Returns a structured result the workflow uses
+ * to call `gh pr create`.
+ *
+ * On a stage/commit failure (nothing committed yet), the branch is deleted and
+ * the caller is returned to the original HEAD so the repo is left clean. On a
+ * push failure, the commit already exists — the branch is left in place instead
+ * so the user's work is not lost; the error includes a retry instruction.
+ */
+function cmdPrSubrepo(cwd, repo, branch, commitMessage, raw) {
+    if (!repo) {
+        error('--repo required');
+    }
+    if (!branch) {
+        error('--branch required');
+    }
+    if (!commitMessage || commitMessage.startsWith('--')) {
+        error('commit message required');
+    }
+    if (branch.startsWith('-')) {
+        error(`Branch name must not start with '-': ${branch}`);
+    }
+    // 0. Security: validate repo path is contained within the workspace root.
+    //    Uses security.cjs validatePath (symlink-safe realpathSync + startsWith guard)
+    //    to reject ../escape, absolute paths, and symlink traversal.
+    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/unbound-method
+    const { validatePath } = require('./security.cjs');
+    const pathCheck = validatePath(repo, cwd);
+    if (!pathCheck.safe) {
+        error(`Sub-repo path is unsafe: ${pathCheck.error}`);
+    }
+    const repoCwd = pathCheck.resolved;
+    if (!node_fs_1.default.existsSync(repoCwd)) {
+        error(`Sub-repo not found: ${repoCwd}`);
+    }
+    // 1. Collect changed files via porcelain status — explicit, never git add -A.
+    //    ?? (untracked) lines are excluded — only stage tracked modifications.
+    const statusResult = (0, shell_command_projection_cjs_1.execGit)(['-c', 'core.quotePath=false', 'status', '--porcelain'], { cwd: repoCwd });
+    if (statusResult.exitCode !== 0) {
+        error(`git status failed in ${repo}: ${statusResult.stderr}`);
+    }
+    // Parse porcelain output into two lists:
+    //   changedFiles — all affected paths (old + new for renames) → goes into result.files
+    //   filesToStage — paths to pass to git add (rename old-paths are already staged by
+    //                  the rename op and no longer exist in the worktree; only add new paths)
+    const changedFiles = [];
+    const filesToStage = [];
+    for (const line of statusResult.stdout.split('\n').filter(Boolean).filter(l => !l.startsWith('??'))) {
+        // execGit trims the entire stdout string, which may strip the leading X-status
+        // space from the first output line. Normalize before slicing.
+        const normalized = line.trimStart();
+        const file = normalized.slice(2).trim();
+        const arrowIdx = file.indexOf(' -> ');
+        if (arrowIdx !== -1) {
+            const oldPath = file.slice(0, arrowIdx).trim();
+            const newPath = file.slice(arrowIdx + 4).trim();
+            changedFiles.push(oldPath, newPath);
+            filesToStage.push(newPath); // old path already staged; worktree no longer has it
+        }
+        else {
+            changedFiles.push(file);
+            filesToStage.push(file);
+        }
+    }
+    if (changedFiles.length === 0) {
+        output({ ok: true, repo, branch, committed: false, reason: 'nothing_to_commit', files: [] }, raw, 'nothing_to_commit');
+        return;
+    }
+    // 2. Guard: refuse if branch already exists — checkout -b is non-idempotent
+    const branchCheck = (0, shell_command_projection_cjs_1.execGit)(['rev-parse', '--verify', branch], { cwd: repoCwd });
+    if (branchCheck.exitCode === 0) {
+        error(`Branch already exists in ${repo}: ${branch}. Delete it first or choose a unique name.`);
+    }
+    // Capture current HEAD before switching so rollback can return explicitly.
+    // git checkout - fails on a fresh single-branch repo with no prior HEAD.
+    const prevBranchResult = (0, shell_command_projection_cjs_1.execGit)(['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: repoCwd });
+    const prevBranchName = prevBranchResult.exitCode === 0 ? prevBranchResult.stdout.trim() : null;
+    // 3. Create branch
+    const checkoutResult = (0, shell_command_projection_cjs_1.execGit)(['checkout', '-b', branch], { cwd: repoCwd });
+    if (checkoutResult.exitCode !== 0) {
+        error(`Failed to create branch ${branch} in ${repo}: ${checkoutResult.stderr}`);
+    }
+    // Helper: rollback the created branch and return to the previous HEAD.
+    const rollback = () => {
+        if (prevBranchName) {
+            (0, shell_command_projection_cjs_1.execGit)(['checkout', prevBranchName], { cwd: repoCwd });
+        }
+        (0, shell_command_projection_cjs_1.execGit)(['branch', '-D', branch], { cwd: repoCwd });
+    };
+    // 4. Stage explicit files (never git add -A per universal-anti-patterns.md:44)
+    for (const file of filesToStage) {
+        const addResult = (0, shell_command_projection_cjs_1.execGit)(['add', '--', file], { cwd: repoCwd });
+        if (addResult.exitCode !== 0) {
+            rollback();
+            error(`Failed to stage ${file} in ${repo}: ${addResult.stderr}`);
+        }
+    }
+    // 5. Commit
+    const commitResult = (0, shell_command_projection_cjs_1.execGit)(['commit', '-m', commitMessage], { cwd: repoCwd });
+    if (commitResult.exitCode !== 0) {
+        rollback();
+        error(`Failed to commit in ${repo}: ${commitResult.stderr}`);
+    }
+    // 6. Capture commit hash
+    const hashResult = (0, shell_command_projection_cjs_1.execGit)(['rev-parse', '--short', 'HEAD'], { cwd: repoCwd });
+    const commitHash = hashResult.exitCode === 0 ? hashResult.stdout.trim() : null;
+    // 7. Capture remote URL and derive GitHub owner/repo slug for gh pr create
+    const remoteResult = (0, shell_command_projection_cjs_1.execGit)(['remote', 'get-url', 'origin'], { cwd: repoCwd });
+    const remoteUrl = remoteResult.exitCode === 0 ? remoteResult.stdout.trim() : null;
+    let remoteSlug = null;
+    if (remoteUrl) {
+        const m = remoteUrl.match(/github\.com[:/](.+?)(?:\.git)?$/);
+        remoteSlug = m ? m[1] : null;
+    }
+    // 8. Push with --set-upstream so gh pr create can find the branch.
+    //    Network operation — use a longer timeout than the default 10 s.
+    //    Do NOT rollback on push failure — the commit already exists on the local branch.
+    //    Deleting the branch here would destroy the only ref holding the user's work.
+    //    Leave the branch in place so the user can retry the push.
+    const pushResult = (0, shell_command_projection_cjs_1.execGit)(['push', '--set-upstream', 'origin', branch], { cwd: repoCwd, timeout: 60_000 });
+    if (pushResult.exitCode !== 0) {
+        error(`Failed to push ${branch} in ${repo}: ${pushResult.stderr}\nBranch ${branch} was created locally — retry with: git -C ${repo} push --set-upstream origin ${branch}`);
+    }
+    const result = {
+        ok: true,
+        repo,
+        branch,
+        committed: true,
+        files: changedFiles,
+        commit_hash: commitHash,
+        remote_url: remoteUrl,
+        remote_slug: remoteSlug,
+    };
+    output(result, raw, `${repo}@${commitHash ?? 'unknown'}`);
+}
 function cmdSummaryExtract(cwd, summaryPath, fields, raw) {
     if (!summaryPath) {
         error('summary-path required for summary-extract');
@@ -1224,6 +1468,8 @@ module.exports = {
     cmdGenerateSlug,
     cmdCurrentTimestamp,
     cmdListTodos,
+    cmdListSeeds,
+    deriveSeedIdentity,
     cmdVerifyPathExists,
     cmdHistoryDigest,
     cmdResolveModel,
@@ -1232,6 +1478,7 @@ module.exports = {
     cmdEffortSync,
     cmdCommit,
     cmdCommitToSubrepo,
+    cmdPrSubrepo,
     cmdSummaryExtract,
     cmdWebsearch,
     cmdProgressRender,