freeharness 0.4.1 → 0.4.2

package/node_modules/@freeharness/sdd/dist/src/bin/openspec.js

@@ -11,8 +11,9 @@
 // Root resolution is store-free: walk up from the cwd to the nearest openspec/
 // directory (src/root-resolver.ts). Its PARENT is the project root passed to the
 // engine. `context` may run without a root (to report no_openspec_root); `new
-// change` falls back to the cwd as an implicit root; every other command
-// requires a root.
+// change` falls back to the cwd as an implicit root; `list` also accepts a null
+// root (it reports `root: null` and exits 1 instead of throwing, so a caller can
+// probe for a project without a write); every other command requires a root.
 import * as path from 'node:path';
 import { findOpenspecDir } from '../root-resolver.js';
 import { statusHandler } from '../shim/status.js';
@@ -23,9 +24,21 @@ import { contextHandler } from '../shim/context.js';
 import { validateHandler } from '../shim/validate.js';
 import { newChangeHandler } from '../shim/new-change.js';
 import { archiveHandler } from '../shim/archive.js';
-import { followUpAddHandler, followUpClaimHandler, followUpListHandler } from '../shim/follow-up.js';
+import { FOLLOW_UP_TYPES, followUpAddHandler, followUpClaimHandler, followUpListHandler } from '../shim/follow-up.js';
 /** Flags that consume the following token as their value. */
-const VALUE_FLAGS = new Set(['--change', '--schema', '--description', '--sort', '--store', '--type', '--from', '--by']);
+const VALUE_FLAGS = new Set([
+    '--change',
+    '--schema',
+    '--description',
+    '--sort',
+    '--store',
+    '--type',
+    '--from',
+    '--by',
+    '--expected',
+    '--current',
+    '--impact',
+]);
 function parseArgs(argv) {
     const positionals = [];
     const flags = {};
@@ -89,7 +102,9 @@ async function main() {
         case 'schemas':
             return schemasHandler(projectRootFrom(cwd) ?? '', { json });
         case 'list':
-            return await listHandler(requireRoot(cwd), {
+            // Root-optional: a caller probing for a project (the /opsx pre-write check)
+            // reads `root` from a valid JSON document instead of parsing a thrown error.
+            return await listHandler(projectRootFrom(cwd), {
                 json,
                 sort: flags['--sort'] ?? 'recent',
             });
@@ -122,7 +137,16 @@ async function main() {
         case 'follow-up': {
             const root = requireRoot(cwd);
             const sub = positionals[0];
-            const options = { json, from: flags['--from'], by: flags['--by'] };
+            const value = (flag) => flags[flag];
+            const options = {
+                json,
+                from: value('--from'),
+                by: value('--by'),
+                type: value('--type'),
+                expected: value('--expected'),
+                current: value('--current'),
+                impact: value('--impact'),
+            };
             if (sub === 'add')
                 return followUpAddHandler(root, positionals[1], positionals[2], options);
             if (sub === 'list')
@@ -150,8 +174,10 @@ function printUsage() {
         '  schemas [--json]',
         '  context [--json]',
         '  archive <id> [--yes] [--force] [--json]',
-        '  follow-up add <change-id> "<text>" [--from <task>] [--json]',
-        '  follow-up list [--json]',
+        "  follow-up add <change-id> '<text>' --type <type> --expected '<text>' --current '<text>' --impact '<text>' [--from <task>]",
+        '                [--json]',
+        `    <type>: ${FOLLOW_UP_TYPES.join('|')}`,
+        '  follow-up list [--type <type>|untyped] [--json]',
         '  follow-up claim <change-id> <index> --by <change-id> [--json]',
     ].join('\n'));
 }

package/node_modules/@freeharness/sdd/dist/src/shim/archive.d.ts

@@ -1,7 +1,9 @@
 import type { ValidationIssue } from '../../vendor/openspec/validation/types.js';
 import { type UnresolvedDeltaHeader } from '../../vendor/openspec/validation/delta-resolution.js';
+import { type AnnotatedTask } from '../../vendor/openspec/validation/task-lines.js';
 import { type ChangeMetadata } from '../../vendor/openspec/engine/change-metadata.js';
 import { type FollowUpItem } from './follow-up.js';
+import { type ShimWarning } from './warnings.js';
 /** One `Supersedes:` link resolved against openspec/changes/archive/. */
 export interface SupersessionLink {
     /** The superseded (archived) change id. */
@@ -24,7 +26,7 @@ export declare function checkSupersession(changeName: string, changeDir: string,
  * Lines that describe what archive would refuse or what is still open. The
  * unresolved headers are listed here as well so one refusal names everything.
  */
-export declare function listArchiveBlockers(changeDir: string, issues: ValidationIssue[], unresolved?: UnresolvedDeltaHeader[]): string[];
+export declare function listArchiveBlockers(changeDir: string, projectRoot: string, tasks: AnnotatedTask[], issues: ValidationIssue[], unresolved?: UnresolvedDeltaHeader[]): string[];
 /** One unchecked task resolved outside this change. */
 export interface ArchivedDisposition {
     kind: string;
@@ -58,8 +60,10 @@ export interface ArchiveChangeResult {
     skipped: UnresolvedDeltaHeader[];
     /** Unchecked tasks resolved outside this change, grouped for display by kind. */
     dispositions: ArchivedDisposition[];
-    /** The archived change's unclaimed follow-ups, printed as a notice (never a blocker). */
+    /** The archived change's unclaimed follow-ups; reported as a notice, never a blocker. */
     followUps: FollowUpItem[];
+    /** Delta text the fold left out of the main specs; the archive still completes. */
+    warnings: ShimWarning[];
 }
 /**
  * Archive a change: validate it, fold its delta specs into openspec/specs/, then
@@ -74,8 +78,5 @@ export interface ArchiveOptions {
     yes?: boolean;
     force?: boolean;
 }
-/**
- * CLI wrapper for `openspec archive <id>`. Returns the process exit code and
- * emits either the single-document `--json` result or human-readable lines.
- */
+/** CLI wrapper for `openspec archive <id>`: a `--json` document or plain lines; returns the exit code. */
 export declare function archiveHandler(projectRoot: string, changeName: string | undefined, options: ArchiveOptions): Promise<number>;

package/node_modules/@freeharness/sdd/dist/src/shim/archive.js

@@ -7,7 +7,7 @@
 // an invalid change and (2) folds every delta before moving the change, never a
 // move-without-fold that would leave openspec/specs/ stale.
 //
-// V4-P4 additions:
+// Checks and links around the fold:
 // - Archive blockers (#1710 findArchiveBlockers, reported INFO by the validator)
 //   and unchecked tasks are listed before anything is written; without `--yes`
 //   they refuse the archive (upstream prompts; this shim is non-interactive).
@@ -29,13 +29,15 @@ import * as fssync from 'node:fs';
 import * as path from 'node:path';
 import { Validator } from '../../vendor/openspec/validation/validator.js';
 import { findSpecUpdates, buildUpdatedSpec, writeUpdatedSpec, } from '../../vendor/openspec/apply/specs-apply.js';
-import { parseDeltaSpec } from '../../vendor/openspec/validation/parsers/requirement-blocks.js';
+import { describeUnappliedContent, findUnappliedContent, parseDeltaSpec, } from '../../vendor/openspec/validation/parsers/requirement-blocks.js';
 import { discoverSpecFiles } from '../../vendor/openspec/validation/spec-discovery.js';
 import { findUnresolvedDeltaHeaders, } from '../../vendor/openspec/validation/delta-resolution.js';
 import { parseAnnotatedTaskLines } from '../../vendor/openspec/validation/task-lines.js';
 import { readChangeMetadata } from '../../vendor/openspec/engine/change-metadata.js';
-import { changesDirFor, resolveChangeId, taskLabel, validateChangeExists } from './shared.js';
-import { readFollowUps } from './follow-up.js';
+import { changesDirFor, findMissingTaskCheckboxWarning, resolveChangeId, taskLabel, validateChangeExists, } from './shared.js';
+import { formatFollowUpGroups, readFollowUps } from './follow-up.js';
+import { dispositionReason } from './validate.js';
+import { unappliedDeltaContentWarning } from './warnings.js';
 const SUPERSEDES_LINE = /^\s*Supersedes:\s*(.+?)\s*$/gm;
 const SUPERSEDED_BY_PREFIX = 'Superseded-by:';
 /**
@@ -147,11 +149,18 @@ async function writeSupersededBy(link, changeName) {
     const separator = existing.length === 0 ? '' : existing.endsWith('\n') ? '\n' : '\n\n';
     await fs.writeFile(designPath, `${existing}${separator}${line}\n`, 'utf-8');
 }
+/** The change's tasks.md parsed once for archive's task checks; empty when absent. */
+function readTasks(changeDir) {
+    const tasksPath = path.join(changeDir, 'tasks.md');
+    if (!fssync.existsSync(tasksPath))
+        return [];
+    return parseAnnotatedTaskLines(fssync.readFileSync(tasksPath, 'utf-8'));
+}
 /**
  * Lines that describe what archive would refuse or what is still open. The
  * unresolved headers are listed here as well so one refusal names everything.
  */
-export function listArchiveBlockers(changeDir, issues, unresolved = []) {
+export function listArchiveBlockers(changeDir, projectRoot, tasks, issues, unresolved = []) {
     const blockers = [];
     for (const issue of issues) {
         if (issue.level === 'INFO' && /^Archive would refuse this delta/.test(issue.message)) {
@@ -160,37 +169,22 @@ export function listArchiveBlockers(changeDir, issues, unresolved = []) {
     }
     for (const u of unresolved)
         blockers.push(`[WARNING] ${u.entryPath}: ${u.message}`);
-    const tasksPath = path.join(changeDir, 'tasks.md');
-    if (fssync.existsSync(tasksPath)) {
-        // A dispositioned task is resolved outside this change (see
-        // dispositionedTasks below), so it is never a blocker; only a plain
-        // unchecked task refuses the archive.
-        const open = parseAnnotatedTaskLines(fssync.readFileSync(tasksPath, 'utf-8')).filter((t) => !t.done && !t.disposition);
-        if (open.length > 0) {
-            blockers.push(`[INFO] tasks.md: ${open.length} unchecked task(s); first: ${open[0].description || '(no description)'}`);
-        }
+    // A dispositioned task is resolved outside this change (see
+    // dispositionedTasks below), so it is never a blocker; only a plain
+    // unchecked task refuses the archive.
+    const open = tasks.filter((t) => !t.done && !t.disposition);
+    if (open.length > 0) {
+        blockers.push(`[INFO] tasks.md: ${open.length} unchecked task(s); first: ${open[0].description || '(no description)'}`);
     }
-    return blockers;
-}
-const DISPOSITION_KINDS = new Set(['superseded', 'moved', 'external']);
-/**
- * Why a task's disposition does not resolve it, or null when it does: a kind
- * outside the three documented ones, an `external` line without a reference,
- * or a `superseded`/`moved` target `resolveChangeId` cannot place in flight or
- * archived. Re-checked here (not merely trusted from an earlier `validate`
- * run) the same way `listDependencyBlockers` below re-checks `depends_on`.
- */
-function dispositionBlockerReason(projectRoot, disposition) {
-    const { kind, target } = disposition;
-    if (!DISPOSITION_KINDS.has(kind)) {
-        return `disposition kind '${kind}' is none of superseded, moved, external`;
-    }
-    if (kind === 'external') {
-        return target.trim() === '' ? 'an external disposition needs a reference' : null;
+    // A tasks file written as plain bullets carries zero checkboxes, so the
+    // scan above finds no open task and archive would otherwise proceed with
+    // unfinished work unflagged (#1774).
+    const checkboxWarning = findMissingTaskCheckboxWarning(changeDir, projectRoot);
+    if (checkboxWarning) {
+        // The warning already opens with `<path>:<line>`, so it takes no path prefix.
+        blockers.push(`[INFO] ${checkboxWarning}`);
     }
-    return resolveChangeId(projectRoot, target) === null
-        ? `${kind} disposition names unresolved change '${target}'`
-        : null;
+    return blockers;
 }
 /**
  * The change's dispositioned tasks (unchecked, carrying a `Disposition:`
@@ -199,11 +193,7 @@ function dispositionBlockerReason(projectRoot, disposition) {
  * disposition does not resolve is still listed here for display, but also
  * comes back as a blocker from `listDispositionBlockers`.
  */
-function dispositionedTasks(changeDir) {
-    const tasksPath = path.join(changeDir, 'tasks.md');
-    if (!fssync.existsSync(tasksPath))
-        return [];
-    const tasks = parseAnnotatedTaskLines(fssync.readFileSync(tasksPath, 'utf-8'));
+function dispositionedTasks(tasks) {
     const out = [];
     for (const task of tasks) {
         if (task.done || !task.disposition)
@@ -221,18 +211,16 @@ function dispositionedTasks(changeDir) {
  * unknown kind, an unresolved `superseded`/`moved` target, or an empty
  * `external` reference), naming the task and the reason. Such a task stays a
  * blocker exactly like a plain unchecked task; a resolving disposition never
- * appears here.
+ * appears here. The reasons are `validate`'s, re-checked here (not merely
+ * trusted from an earlier `validate` run) the same way
+ * `listDependencyBlockers` below re-checks `depends_on`.
  */
-function listDispositionBlockers(projectRoot, changeDir) {
-    const tasksPath = path.join(changeDir, 'tasks.md');
-    if (!fssync.existsSync(tasksPath))
-        return [];
-    const tasks = parseAnnotatedTaskLines(fssync.readFileSync(tasksPath, 'utf-8'));
+function listDispositionBlockers(projectRoot, tasks) {
     const blockers = [];
     for (const task of tasks) {
         if (task.done || !task.disposition)
             continue;
-        const reason = dispositionBlockerReason(projectRoot, task.disposition);
+        const reason = dispositionReason(projectRoot, task.disposition);
         if (reason) {
             blockers.push(`[INFO] tasks.md: task ${taskLabel(task)} disposition does not resolve it (${reason})`);
         }
@@ -281,6 +269,18 @@ async function forcedFoldBlockers(changeDir, specsDir, changeName) {
     }
     return out;
 }
+/**
+ * The fold's warnings about delta text it leaves behind, told apart from its
+ * other warnings by the span description they open with, so the orphan and
+ * `--force` notices keep their own handling.
+ */
+async function unappliedContentWarnings(update, foldWarnings) {
+    const content = await fs.readFile(update.source, 'utf-8');
+    const prefixes = findUnappliedContent(content).map((lost) => `${update.id} - ${describeUnappliedContent(lost)} (line ${lost.line})`);
+    return foldWarnings
+        .filter((message) => prefixes.some((prefix) => message.startsWith(prefix)))
+        .map((message) => unappliedDeltaContentWarning(update.id, message));
+}
 /**
  * Archive a change: validate it, fold its delta specs into openspec/specs/, then
  * move openspec/changes/<name>/ to openspec/changes/archive/<name>/.
@@ -329,18 +329,19 @@ export async function archiveChange(changeName, { projectRoot, yes, force }) {
     //     unchecked tasks. Listed together; without --yes they refuse the archive
     //     with nothing written (upstream asks; this shim cannot).
     const unresolved = await findUnresolvedDeltaHeaders(changeDir, specsDir, changesDir);
+    const tasks = readTasks(changeDir);
     const dependencyBlockers = listDependencyBlockers(projectRoot, metadata);
-    const dispositionBlockers = listDispositionBlockers(projectRoot, changeDir);
+    const dispositionBlockers = listDispositionBlockers(projectRoot, tasks);
     const blockers = force
         ? [
             ...(await forcedFoldBlockers(changeDir, specsDir, name)),
-            ...listArchiveBlockers(changeDir, report.issues.filter((i) => !/^Archive would refuse this delta/.test(i.message))),
+            ...listArchiveBlockers(changeDir, projectRoot, tasks, report.issues.filter((i) => !/^Archive would refuse this delta/.test(i.message))),
             ...metadataBlockers,
             ...dependencyBlockers,
             ...dispositionBlockers,
         ]
         : [
-            ...listArchiveBlockers(changeDir, report.issues, unresolved),
+            ...listArchiveBlockers(changeDir, projectRoot, tasks, report.issues, unresolved),
             ...metadataBlockers,
             ...dependencyBlockers,
             ...dispositionBlockers,
@@ -360,9 +361,9 @@ export async function archiveChange(changeName, { projectRoot, yes, force }) {
     }
     // 1d. Supersession links (design.md `Supersedes:`), checked before any write.
     const supersedes = await checkSupersession(name, changeDir, changesDir, metadata);
-    // 1e. Dispositioned tasks, read while the change still sits at changeDir (the
-    //     move below relocates it).
-    const dispositions = dispositionedTasks(changeDir);
+    // 1e. Dispositioned tasks, from the parse taken while the change still sat at
+    //     changeDir (the move below relocates it).
+    const dispositions = dispositionedTasks(tasks);
     // 2. Fold the change's delta specs into openspec/specs/. buildUpdatedSpec does
     //    the ADDED/MODIFIED/REMOVED/RENAMED merge; writeUpdatedSpec writes it in
     //    place. A fold that resolves to zero operations is an already-synced
@@ -379,9 +380,11 @@ export async function archiveChange(changeName, { projectRoot, yes, force }) {
     const updates = await findSpecUpdates(changeDir, specsDir);
     const plan = [];
     const skipUnresolved = force === true && unresolved.length > 0;
+    const warnings = [];
     for (const update of updates) {
         const built = await buildUpdatedSpec(update, name, { silent: true, skipUnresolved });
         plan.push({ update, rebuilt: built.rebuilt, counts: built.counts });
+        warnings.push(...(await unappliedContentWarnings(update, built.warnings)));
     }
     const applied = [];
     for (const { update, rebuilt, counts } of plan) {
@@ -403,17 +406,20 @@ export async function archiveChange(changeName, { projectRoot, yes, force }) {
     // 4. Reverse links: the superseded archived record names its successor.
     for (const link of supersedes)
         await writeSupersededBy(link, name);
-    // 5. Open follow-ups, read from the archived location (the file moved with the
-    //    directory in step 3): printed as a notice, never a blocker. An item is open
-    //    while its checkbox is unchecked, the rule `follow-up list`, `follow-up claim`
-    //    and the session-start pointer read it by, so the four never disagree.
+    // 5. Open follow-ups, read where step 3 moved them: a notice, never a blocker. Open
+    //    means unchecked, as for `follow-up list`, `claim` and the session-start pointer.
     const followUps = readFollowUps(archivedTo).filter((item) => !item.done);
-    return { applied, archivedTo, supersedes, skipped: skipUnresolved ? unresolved : [], dispositions, followUps };
+    return {
+        applied,
+        archivedTo,
+        supersedes,
+        skipped: skipUnresolved ? unresolved : [],
+        dispositions,
+        followUps,
+        warnings,
+    };
 }
-/**
- * CLI wrapper for `openspec archive <id>`. Returns the process exit code and
- * emits either the single-document `--json` result or human-readable lines.
- */
+/** CLI wrapper for `openspec archive <id>`: a `--json` document or plain lines; returns the exit code. */
 export async function archiveHandler(projectRoot, changeName, options) {
     try {
         const result = await archiveChange(changeName, {
@@ -431,6 +437,7 @@ export async function archiveHandler(projectRoot, changeName, options) {
                 skipped: result.skipped.map((u) => ({ operation: u.operation, header: u.header, spec: u.specId, ...(u.addedBy ? { addedBy: u.addedBy } : {}) })),
                 dispositions: result.dispositions,
                 followUps: result.followUps,
+                warnings: result.warnings,
             }, null, 2));
         }
         else {
@@ -446,6 +453,8 @@ export async function archiveHandler(projectRoot, changeName, options) {
             for (const u of result.skipped) {
                 console.log(`Warning (--force): skipped ${u.operation} "${u.header}" in specs/${u.entryPath} — ${u.message}`);
             }
+            for (const warning of result.warnings)
+                console.log(`Warning: ${warning.message}`);
             if (result.dispositions.length > 0) {
                 console.log('Dispositions:');
                 const byKind = new Map();
@@ -461,9 +470,8 @@ export async function archiveHandler(projectRoot, changeName, options) {
             }
             if (result.followUps.length > 0) {
                 console.log(`follow-ups open: ${result.followUps.length}`);
-                for (const item of result.followUps) {
-                    const suffix = item.from ? ` (from ${item.from})` : '';
-                    console.log(`  ${item.index}. ${item.text}${suffix}`);
+                for (const line of formatFollowUpGroups(result.followUps, { heading: '  ', item: '    ' }, (item) => `${item.index}. `)) {
+                    console.log(line);
                 }
             }
             console.log(`Archived change to ${result.archivedTo}`);

package/node_modules/@freeharness/sdd/dist/src/shim/follow-up.d.ts

@@ -1,3 +1,9 @@
+export declare const TEMPLATE: string;
+/** The known item types, in display order; `untyped` follows them. */
+export declare const FOLLOW_UP_TYPES: readonly ["defect", "hardening", "refactor", "test-gap", "docs", "design", "owner-step", "upstream"];
+/** A known type, or `untyped` for an item line without a known `[<type>]` tag. */
+export type FollowUpType = (typeof FOLLOW_UP_TYPES)[number] | 'untyped';
+export declare const DISPLAY_ORDER: readonly FollowUpType[];
 /** One follow-up item, its 1-based position among item lines in file order. */
 export interface FollowUpItem {
     index: number;
@@ -7,32 +13,43 @@ export interface FollowUpItem {
     done: boolean;
     /** The claiming change id, null for an item checked by hand with no `-> claimed by` suffix. */
     claimedBy: string | null;
+    type: FollowUpType;
+    /** Context lines under the item; an absent line reads as "". */
+    expected: string;
+    current: string;
+    impact: string;
 }
 /**
- * Reads every item line of a change's follow-ups.md, ignoring any other line
- * (heading, blank, comment). Index is the 1-based position among item lines in
- * file order. Absent file -> empty list.
+ * Reads every item of a change's follow-ups.md with its type and context.
+ * Absent file -> empty list.
  */
 export declare function readFollowUps(dir: string): FollowUpItem[];
+/** A new item as `follow-up add` receives it; every field is validated before any write. */
+export interface NewFollowUp {
+    text: string;
+    type: string;
+    expected: string;
+    current: string;
+    impact: string;
+    from?: string;
+}
 export interface AddFollowUpResult {
     change: string;
     index: number;
 }
 /**
- * Appends an unclaimed item to a change's follow-ups.md, creating the file from
- * the template when absent. Throws when the change resolves neither in flight
- * nor archived.
+ * Appends an unclaimed item and its three context lines to a change's
+ * follow-ups.md in one write, creating the file from the template when absent.
+ * Throws, writing nothing, on an invalid field or when the change resolves
+ * neither in flight nor archived.
  */
-export declare function addFollowUp(projectRoot: string, changeId: string, text: string, from?: string): AddFollowUpResult;
-export interface ListedFollowUp {
+export declare function addFollowUp(projectRoot: string, changeId: string, item: NewFollowUp): AddFollowUpResult;
+export type ListedFollowUp = Omit<FollowUpItem, 'done' | 'claimedBy'> & {
     change: string;
-    index: number;
-    text: string;
-    from: string | null;
     state: 'open';
-}
-/** Every open (unchecked) item of every in-flight and archived change. */
-export declare function listFollowUps(projectRoot: string): ListedFollowUp[];
+};
+/** Every open (unchecked) item of every in-flight and archived change, optionally of one type. */
+export declare function listFollowUps(projectRoot: string, type?: FollowUpType): ListedFollowUp[];
 export interface ClaimFollowUpResult {
     change: string;
     index: number;
@@ -48,10 +65,25 @@ export interface FollowUpCommandOptions {
     json?: boolean;
     from?: string;
     by?: string;
+    type?: string;
+    expected?: string;
+    current?: string;
+    impact?: string;
 }
-/** CLI wrapper for `openspec follow-up add <change-id> "<text>" [--from <task>]`. */
+/**
+ * Lines grouped by type, with C0, DEL, C1, U+2028 and U+2029 removed from each,
+ * since a hand-edited record never passed add's validation; `--json` prints raw values.
+ */
+export declare function formatFollowUpGroups<T extends Omit<FollowUpItem, 'done' | 'claimedBy'>>(items: readonly T[], indent: {
+    heading: string;
+    item: string;
+}, label: (item: T) => string): string[];
+/**
+ * CLI wrapper for `openspec follow-up add <change-id> '<text>' --type <type>
+ * --expected '<text>' --current '<text>' --impact '<text>' [--from <task>]`.
+ */
 export declare function followUpAddHandler(projectRoot: string, changeId: string | undefined, text: string | undefined, options: FollowUpCommandOptions): number;
-/** CLI wrapper for `openspec follow-up list [--json]`. */
+/** CLI wrapper for `openspec follow-up list [--type <type>] [--json]`. */
 export declare function followUpListHandler(projectRoot: string, options: FollowUpCommandOptions): number;
 /** CLI wrapper for `openspec follow-up claim <change-id> <index> --by <change-id>`. */
 export declare function followUpClaimHandler(projectRoot: string, changeId: string | undefined, indexArg: string | undefined, options: FollowUpCommandOptions): number;