freeharness 0.4.1

package/node_modules/@freeharness/sdd/dist/vendor/openspec/engine/schema.js

@@ -0,0 +1,110 @@
+// Vendored faithfully from @fission-ai/openspec@1.8.0
+//   src/core/artifact-graph/schema.ts
+// No behavioural changes. Part of the schema-validation slice.
+import * as fs from 'node:fs';
+import { parse as parseYaml } from 'yaml';
+import { SchemaYamlSchema } from './types.js';
+export class SchemaValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SchemaValidationError';
+    }
+}
+/**
+ * Loads and validates an artifact schema from a YAML file.
+ */
+export function loadSchema(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return parseSchema(content);
+}
+/**
+ * Parses and validates an artifact schema from YAML content.
+ */
+export function parseSchema(yamlContent) {
+    const parsed = parseYaml(yamlContent);
+    // Validate with Zod
+    const result = SchemaYamlSchema.safeParse(parsed);
+    if (!result.success) {
+        const errors = result.error.issues.map(e => `${e.path.join('.')}: ${e.message}`).join(', ');
+        throw new SchemaValidationError(`Invalid schema: ${errors}`);
+    }
+    const schema = result.data;
+    // Check for duplicate artifact IDs
+    validateNoDuplicateIds(schema.artifacts);
+    // Check that all requires references are valid
+    validateRequiresReferences(schema.artifacts);
+    // Check for cycles
+    validateNoCycles(schema.artifacts);
+    return schema;
+}
+/**
+ * Validates that there are no duplicate artifact IDs.
+ */
+function validateNoDuplicateIds(artifacts) {
+    const seen = new Set();
+    for (const artifact of artifacts) {
+        if (seen.has(artifact.id)) {
+            throw new SchemaValidationError(`Duplicate artifact ID: ${artifact.id}`);
+        }
+        seen.add(artifact.id);
+    }
+}
+/**
+ * Validates that all `requires` references point to valid artifact IDs.
+ */
+function validateRequiresReferences(artifacts) {
+    const validIds = new Set(artifacts.map(a => a.id));
+    for (const artifact of artifacts) {
+        for (const req of artifact.requires) {
+            if (!validIds.has(req)) {
+                throw new SchemaValidationError(`Invalid dependency reference in artifact '${artifact.id}': '${req}' does not exist`);
+            }
+        }
+    }
+}
+/**
+ * Validates that there are no cyclic dependencies.
+ * Uses DFS to detect cycles and reports the full cycle path.
+ */
+function validateNoCycles(artifacts) {
+    const artifactMap = new Map(artifacts.map(a => [a.id, a]));
+    const visited = new Set();
+    const inStack = new Set();
+    const parent = new Map();
+    function dfs(id) {
+        visited.add(id);
+        inStack.add(id);
+        const artifact = artifactMap.get(id);
+        if (!artifact)
+            return null;
+        for (const dep of artifact.requires) {
+            if (!visited.has(dep)) {
+                parent.set(dep, id);
+                const cycle = dfs(dep);
+                if (cycle)
+                    return cycle;
+            }
+            else if (inStack.has(dep)) {
+                // Found a cycle - reconstruct the path
+                const cyclePath = [dep];
+                let current = id;
+                while (current !== dep) {
+                    cyclePath.unshift(current);
+                    current = parent.get(current);
+                }
+                cyclePath.unshift(dep);
+                return cyclePath.join(' → ');
+            }
+        }
+        inStack.delete(id);
+        return null;
+    }
+    for (const artifact of artifacts) {
+        if (!visited.has(artifact.id)) {
+            const cycle = dfs(artifact.id);
+            if (cycle) {
+                throw new SchemaValidationError(`Cyclic dependency detected: ${cycle}`);
+            }
+        }
+    }
+}

package/node_modules/@freeharness/sdd/dist/vendor/openspec/engine/state.d.ts

@@ -0,0 +1,11 @@
+import type { CompletedSet } from './types.js';
+import type { ArtifactGraph } from './graph.js';
+/**
+ * Detects which artifacts are completed by checking file existence in the change directory.
+ * Returns a Set of completed artifact IDs.
+ *
+ * @param graph - The artifact graph to check
+ * @param changeDir - The change directory to scan for files
+ * @returns Set of artifact IDs whose generated files exist
+ */
+export declare function detectCompleted(graph: ArtifactGraph, changeDir: string): CompletedSet;

package/node_modules/@freeharness/sdd/dist/vendor/openspec/engine/state.js

@@ -0,0 +1,32 @@
+// Vendored VERBATIM from @fission-ai/openspec@1.8.0 src/core/artifact-graph/state.ts
+// (import paths already resolve within this vendored engine directory).
+import * as fs from 'node:fs';
+import { artifactOutputExists } from './outputs.js';
+/**
+ * Detects which artifacts are completed by checking file existence in the change directory.
+ * Returns a Set of completed artifact IDs.
+ *
+ * @param graph - The artifact graph to check
+ * @param changeDir - The change directory to scan for files
+ * @returns Set of artifact IDs whose generated files exist
+ */
+export function detectCompleted(graph, changeDir) {
+    const completed = new Set();
+    // Handle missing change directory gracefully
+    if (!fs.existsSync(changeDir)) {
+        return completed;
+    }
+    for (const artifact of graph.getAllArtifacts()) {
+        if (isArtifactComplete(artifact.generates, changeDir)) {
+            completed.add(artifact.id);
+        }
+    }
+    return completed;
+}
+/**
+ * Checks if an artifact is complete by checking if its generated file(s) exist.
+ * Supports both simple paths and glob patterns.
+ */
+function isArtifactComplete(generates, changeDir) {
+    return artifactOutputExists(changeDir, generates);
+}

package/node_modules/@freeharness/sdd/dist/vendor/openspec/engine/task-progress.d.ts

@@ -0,0 +1,33 @@
+export interface ParsedTask {
+    done: boolean;
+    description: string;
+}
+export declare function parseTaskLines(content: string): ParsedTask[];
+export interface TaskProgress {
+    total: number;
+    /** Upstream field name, an alias of `done`. */
+    completed: number;
+    /** Checked tasks. Same count as `completed`. */
+    done: number;
+    /** Unchecked tasks carrying no disposition. */
+    open: number;
+    /** Unchecked tasks carrying a `Disposition:` line. */
+    dispositioned: number;
+}
+export declare function countTasksFromContent(content: string): TaskProgress;
+/** Resolves the task files selected by the schema's apply tracking rule. */
+export declare function resolveTaskFilesForChange(changeDir: string, projectRoot: string): string[];
+/**
+ * Computes a change's task progress by resolving its tracked-tasks artifact and
+ * counting checkboxes across every matched file, falling back to a single
+ * top-level `tasks.md`.
+ */
+export declare function getTaskProgressForChange(changesDir: string, changeName: string, projectRoot: string): Promise<TaskProgress>;
+/**
+ * One-line task status. A caller that knows the disposition-aware counts passes them: a
+ * change with no open task is complete even while an unchecked, dispositioned task remains,
+ * and the dispositioned count is named so the gap between `completed` and `total` is
+ * accounted for. A caller passing only the two upstream fields reads every unchecked task
+ * as open.
+ */
+export declare function formatTaskStatus(progress: Pick<TaskProgress, 'total' | 'completed'> & Partial<Pick<TaskProgress, 'open' | 'dispositioned'>>): string;

package/node_modules/@freeharness/sdd/dist/vendor/openspec/engine/task-progress.js

@@ -0,0 +1,149 @@
+// Vendored (store-free) from @fission-ai/openspec@1.8.0 src/utils/task-progress.ts.
+// The checkbox parsing (parseTaskLines / countTasksFromContent) and the
+// tracked-tasks resolution (schema apply.tracks -> generates glob ->
+// resolveArtifactOutputs, with a single top-level tasks.md fallback) are
+// faithful. The only changes are import paths (rewritten to this engine
+// directory) and dropping the run-scoped SchemaGlobCache / --archived plumbing,
+// which the list shim does not need. Schema resolution goes through the
+// store-free resolveSchemaForChange (explicit -> metadata -> spec-driven).
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import { resolveSchema } from './resolver.js';
+import { resolveArtifactOutputs } from './outputs.js';
+import { resolveSchemaForChange } from './change-metadata.js';
+/**
+ * A Markdown task line: a `-`/`*` bullet carrying a `[ ]` or `[x]` checkbox.
+ * Leading whitespace is allowed so nested sub-tasks count like their parents.
+ */
+const TASK_LINE_PATTERN = /^\s*[-*]\s*\[([\sxX])\]\s*(.*)/;
+export function parseTaskLines(content) {
+    const tasks = [];
+    for (const line of content.split('\n')) {
+        const match = line.match(TASK_LINE_PATTERN);
+        if (match) {
+            tasks.push({ done: match[1].toLowerCase() === 'x', description: match[2].trim() });
+        }
+    }
+    return tasks;
+}
+// ---------------------------------------------------------------------------
+// FreeHarness: disposition-aware counting. Not in upstream.
+//
+// This file keeps its own faithful-to-upstream `parseTaskLines` above (no
+// annotation awareness) so task-numbering-style consumers are unaffected;
+// `countTasksFromContent` needs to tell a plain open task from one resolved
+// elsewhere, so it scans annotation lines locally rather than importing the
+// validation-layer parser (this engine directory does not depend on
+// ../validation).
+// ---------------------------------------------------------------------------
+// The trailing `\s*` absorbs the `\r` of a CRLF file, which `.` never matches; without it no
+// annotation of such a file parses and every disposition in it is dropped.
+const TASK_ANNOTATION_PATTERN = /^\s*(?:Verify|Interfaces|Boundary|Depends|Disposition):\s*(.*)\s*$/;
+const DISPOSITION_LINE_PATTERN = /^\s*Disposition:\s*(\S+)/;
+/** Kinds that resolve a task. Any other kind leaves it open, and validate refuses it. */
+const DISPOSITION_KINDS = new Set(['superseded', 'moved', 'external']);
+/** Parses task lines, marking each unchecked task that carries a `Disposition:` line. */
+function parseTasksWithDisposition(content) {
+    const tasks = [];
+    let current;
+    for (const line of content.split('\n')) {
+        const task = line.match(TASK_LINE_PATTERN);
+        if (task) {
+            current = { done: task[1].toLowerCase() === 'x', description: task[2].trim(), dispositioned: false };
+            tasks.push(current);
+            continue;
+        }
+        if (current && TASK_ANNOTATION_PATTERN.test(line)) {
+            const disposition = DISPOSITION_LINE_PATTERN.exec(line);
+            if (disposition && DISPOSITION_KINDS.has(disposition[1]))
+                current.dispositioned = true;
+            continue;
+        }
+        current = undefined;
+    }
+    return tasks;
+}
+export function countTasksFromContent(content) {
+    const tasks = parseTasksWithDisposition(content);
+    const done = tasks.filter((task) => task.done).length;
+    const dispositioned = tasks.filter((task) => !task.done && task.dispositioned).length;
+    const open = tasks.length - done - dispositioned;
+    return { total: tasks.length, completed: done, done, open, dispositioned };
+}
+/**
+ * Identifies the change's tracked-tasks artifact: the artifact whose `generates`
+ * equals the schema's `apply.tracks`, falling back to the artifact with id
+ * `tasks` when no `apply` block declares what it tracks.
+ */
+function findTrackedTasksArtifact(schema) {
+    const tracks = schema.apply?.tracks;
+    if (tracks != null) {
+        return schema.artifacts.find((a) => a.generates === tracks);
+    }
+    return schema.artifacts.find((a) => a.id === 'tasks');
+}
+function resolveTrackedTasksGlob(changeDir, projectRoot) {
+    try {
+        const schemaName = resolveSchemaForChange(changeDir, undefined, projectRoot);
+        const schema = resolveSchema(schemaName, projectRoot);
+        return findTrackedTasksArtifact(schema)?.generates;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Resolves the task files selected by the schema's apply tracking rule. */
+export function resolveTaskFilesForChange(changeDir, projectRoot) {
+    const generates = resolveTrackedTasksGlob(changeDir, projectRoot);
+    return generates ? resolveArtifactOutputs(changeDir, generates) : [];
+}
+async function countTaskFile(file) {
+    try {
+        const content = await fs.readFile(file, 'utf-8');
+        return countTasksFromContent(content);
+    }
+    catch {
+        return { total: 0, completed: 0, done: 0, open: 0, dispositioned: 0 };
+    }
+}
+/**
+ * Computes a change's task progress by resolving its tracked-tasks artifact and
+ * counting checkboxes across every matched file, falling back to a single
+ * top-level `tasks.md`.
+ */
+export async function getTaskProgressForChange(changesDir, changeName, projectRoot) {
+    const changeDir = path.join(changesDir, changeName);
+    const files = resolveTaskFilesForChange(changeDir, projectRoot);
+    const targets = files.length > 0 ? files : [path.join(changeDir, 'tasks.md')];
+    let total = 0;
+    let completed = 0;
+    let done = 0;
+    let open = 0;
+    let dispositioned = 0;
+    for (const file of targets) {
+        const progress = await countTaskFile(file);
+        total += progress.total;
+        completed += progress.completed;
+        done += progress.done;
+        open += progress.open;
+        dispositioned += progress.dispositioned;
+    }
+    return { total, completed, done, open, dispositioned };
+}
+/**
+ * One-line task status. A caller that knows the disposition-aware counts passes them: a
+ * change with no open task is complete even while an unchecked, dispositioned task remains,
+ * and the dispositioned count is named so the gap between `completed` and `total` is
+ * accounted for. A caller passing only the two upstream fields reads every unchecked task
+ * as open.
+ */
+export function formatTaskStatus(progress) {
+    if (progress.total === 0)
+        return 'No tasks';
+    const open = progress.open ?? progress.total - progress.completed;
+    if (open === 0)
+        return '✓ Complete';
+    const dispositioned = progress.dispositioned ?? 0;
+    const aside = dispositioned > 0 ? ` (${dispositioned} dispositioned)` : '';
+    return `${progress.completed}/${progress.total} tasks${aside}`;
+}

package/node_modules/@freeharness/sdd/dist/vendor/openspec/engine/types.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export declare const ArtifactSchema: z.ZodObject<{
+    id: z.ZodString;
+    generates: z.ZodString;
+    description: z.ZodString;
+    template: z.ZodString;
+    instruction: z.ZodOptional<z.ZodString>;
+    requires: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const ApplyPhaseSchema: z.ZodObject<{
+    requires: z.ZodArray<z.ZodString>;
+    tracks: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    instruction: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const SchemaYamlSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodNumber;
+    description: z.ZodOptional<z.ZodString>;
+    artifacts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        generates: z.ZodString;
+        description: z.ZodString;
+        template: z.ZodString;
+        instruction: z.ZodOptional<z.ZodString>;
+        requires: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    apply: z.ZodOptional<z.ZodObject<{
+        requires: z.ZodArray<z.ZodString>;
+        tracks: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        instruction: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Artifact = z.infer<typeof ArtifactSchema>;
+export type ApplyPhase = z.infer<typeof ApplyPhaseSchema>;
+export type SchemaYaml = z.infer<typeof SchemaYamlSchema>;
+export type CompletedSet = Set<string>;
+export interface BlockedArtifacts {
+    [artifactId: string]: string[];
+}

package/node_modules/@freeharness/sdd/dist/vendor/openspec/engine/types.js

@@ -0,0 +1,49 @@
+// Vendored faithfully from @fission-ai/openspec@1.8.0
+//   src/core/artifact-graph/types.ts
+// No behavioural changes. Part of the schema-validation slice.
+import * as path from 'node:path';
+import { z } from 'zod';
+function relativePathSchema(fieldName) {
+    return z
+        .string()
+        .min(1, { error: `${fieldName} is required` })
+        .superRefine((value, ctx) => {
+        const segments = value.split(/[\\/]+/u);
+        const isDrivePath = /^[A-Za-z]:/u.test(value);
+        const isAbsolute = path.posix.isAbsolute(value) || path.win32.isAbsolute(value) || isDrivePath;
+        const escapes = segments.includes('..');
+        if (isAbsolute || escapes || value.includes('\0')) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `${fieldName} must be a relative path inside its allowed directory`,
+            });
+        }
+    });
+}
+// Artifact definition schema
+export const ArtifactSchema = z.object({
+    id: z.string().min(1, { error: 'Artifact ID is required' }),
+    generates: relativePathSchema('generates field'),
+    description: z.string(),
+    template: relativePathSchema('template field'),
+    instruction: z.string().optional(),
+    requires: z.array(z.string()).default([]),
+});
+// Apply phase configuration for schema-aware apply instructions
+export const ApplyPhaseSchema = z.object({
+    // Artifact IDs that must exist before apply is available
+    requires: z.array(z.string()).min(1, { error: 'At least one required artifact' }),
+    // Path to file with checkboxes for progress (relative to change dir), or null if no tracking
+    tracks: relativePathSchema('apply.tracks').nullable().optional(),
+    // Custom guidance for the apply phase
+    instruction: z.string().optional(),
+});
+// Full schema YAML structure
+export const SchemaYamlSchema = z.object({
+    name: z.string().min(1, { error: 'Schema name is required' }),
+    version: z.number().int().positive({ error: 'Version must be a positive integer' }),
+    description: z.string().optional(),
+    artifacts: z.array(ArtifactSchema).min(1, { error: 'At least one artifact required' }),
+    // Optional apply phase configuration (for schema-aware apply instructions)
+    apply: ApplyPhaseSchema.optional(),
+});

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/command-generation/adapters/claude.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Claude Code Command Adapter
+ *
+ * Formats commands for Claude Code following its frontmatter specification.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Claude Code adapter for command generation.
+ * File path: .claude/commands/opsx/<id>.md
+ * Frontmatter: name, description, allowed-tools, category, tags
+ */
+export declare const claudeAdapter: ToolCommandAdapter;

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/command-generation/adapters/claude.js

@@ -0,0 +1,31 @@
+/**
+ * Claude Code Command Adapter
+ *
+ * Formats commands for Claude Code following its frontmatter specification.
+ */
+import path from 'path';
+import { escapeYamlValue, formatTagsArray } from '../yaml.js';
+import { OPENSPEC_CLI_ALLOWED_TOOLS } from '../../shared/allowed-tools.js';
+/**
+ * Claude Code adapter for command generation.
+ * File path: .claude/commands/opsx/<id>.md
+ * Frontmatter: name, description, allowed-tools, category, tags
+ */
+export const claudeAdapter = {
+    toolId: 'claude',
+    getFilePath(commandId) {
+        return path.join('.claude', 'commands', 'opsx', `${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+name: ${escapeYamlValue(content.name)}
+description: ${escapeYamlValue(content.description)}
+allowed-tools: ${OPENSPEC_CLI_ALLOWED_TOOLS}
+category: ${escapeYamlValue(content.category)}
+tags: ${formatTagsArray(content.tags)}
+---
+
+${content.body}
+`;
+    },
+};

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/command-generation/adapters/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Command Adapters Index
+ *
+ * Re-exports the tool command adapters.
+ *
+ * FreeHarness trim: reduced from the upstream 29-adapter re-export to the two
+ * harnesses FreeHarness targets (Claude Code + OpenCode).
+ */
+export { claudeAdapter } from './claude.js';
+export { opencodeAdapter } from './opencode.js';

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/command-generation/adapters/index.js

@@ -0,0 +1,10 @@
+/**
+ * Command Adapters Index
+ *
+ * Re-exports the tool command adapters.
+ *
+ * FreeHarness trim: reduced from the upstream 29-adapter re-export to the two
+ * harnesses FreeHarness targets (Claude Code + OpenCode).
+ */
+export { claudeAdapter } from './claude.js';
+export { opencodeAdapter } from './opencode.js';

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/command-generation/adapters/opencode.d.ts

@@ -0,0 +1,12 @@
+/**
+ * OpenCode Command Adapter
+ *
+ * Formats commands for OpenCode following its frontmatter specification.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * OpenCode adapter for command generation.
+ * File path: .opencode/commands/opsx-<id>.md
+ * Frontmatter: description
+ */
+export declare const opencodeAdapter: ToolCommandAdapter;

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/command-generation/adapters/opencode.js

@@ -0,0 +1,26 @@
+/**
+ * OpenCode Command Adapter
+ *
+ * Formats commands for OpenCode following its frontmatter specification.
+ */
+import path from 'path';
+import { escapeYamlValue } from '../yaml.js';
+/**
+ * OpenCode adapter for command generation.
+ * File path: .opencode/commands/opsx-<id>.md
+ * Frontmatter: description
+ */
+export const opencodeAdapter = {
+    toolId: 'opencode',
+    getFilePath(commandId) {
+        return path.join('.opencode', 'commands', `opsx-${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+description: ${escapeYamlValue(content.description)}
+---
+
+${content.body}
+`;
+    },
+};

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/command-generation/generator.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Command Generator
+ *
+ * Functions for generating command files using tool adapters.
+ */
+import type { CommandContent, ToolCommandAdapter, GeneratedCommand } from './types.js';
+/**
+ * Generate a single command file using the provided adapter.
+ *
+ * Command bodies are authored with `/opsx:<id>` references. Tools whose command
+ * files are invoked by filename register `/opsx-<id>` instead, and Amazon Q
+ * surfaces them in its prompt library as `@opsx-<id>`, so the body is rewritten
+ * to the form that tool answers to before the adapter formats it. Doing it here
+ * rather than per adapter keeps every tool in step (#727, #1307); adapters stay
+ * pure formatters.
+ *
+ * @param content - The tool-agnostic command content
+ * @param adapter - The tool-specific adapter
+ * @returns Generated command with path and file content
+ */
+export declare function generateCommand(content: CommandContent, adapter: ToolCommandAdapter): GeneratedCommand;
+/**
+ * Generate multiple command files using the provided adapter.
+ * @param contents - Array of tool-agnostic command contents
+ * @param adapter - The tool-specific adapter
+ * @returns Array of generated commands with paths and file contents
+ */
+export declare function generateCommands(contents: CommandContent[], adapter: ToolCommandAdapter): GeneratedCommand[];

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/command-generation/generator.js

@@ -0,0 +1,41 @@
+/**
+ * Command Generator
+ *
+ * Functions for generating command files using tool adapters.
+ */
+import { getInvocationForAdapter, needsInvocationRewrite } from './invocation.js';
+// FreeHarness: command-references vendored alongside generation/ (was ../../utils).
+import { transformCommandInvocations } from '../command-references.js';
+/**
+ * Generate a single command file using the provided adapter.
+ *
+ * Command bodies are authored with `/opsx:<id>` references. Tools whose command
+ * files are invoked by filename register `/opsx-<id>` instead, and Amazon Q
+ * surfaces them in its prompt library as `@opsx-<id>`, so the body is rewritten
+ * to the form that tool answers to before the adapter formats it. Doing it here
+ * rather than per adapter keeps every tool in step (#727, #1307); adapters stay
+ * pure formatters.
+ *
+ * @param content - The tool-agnostic command content
+ * @param adapter - The tool-specific adapter
+ * @returns Generated command with path and file content
+ */
+export function generateCommand(content, adapter) {
+    const invocation = getInvocationForAdapter(adapter);
+    const formatted = needsInvocationRewrite(invocation)
+        ? { ...content, body: transformCommandInvocations(content.body, invocation) }
+        : content;
+    return {
+        path: adapter.getFilePath(content.id),
+        fileContent: adapter.formatFile(formatted),
+    };
+}
+/**
+ * Generate multiple command files using the provided adapter.
+ * @param contents - Array of tool-agnostic command contents
+ * @param adapter - The tool-specific adapter
+ * @returns Array of generated commands with paths and file contents
+ */
+export function generateCommands(contents, adapter) {
+    return contents.map((content) => generateCommand(content, adapter));
+}

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/command-generation/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Command Generation Module
+ *
+ * Generic command generation system with tool-specific adapters.
+ *
+ * FreeHarness trim: adapter re-export reduced to claude + opencode.
+ *
+ * Usage:
+ * ```typescript
+ * import { generateCommands, CommandAdapterRegistry, type CommandContent } from './command-generation/index.js';
+ *
+ * const contents: CommandContent[] = [...];
+ * const adapter = CommandAdapterRegistry.get('claude');
+ * if (adapter) {
+ *   const commands = generateCommands(contents, adapter);
+ *   // Write commands to disk
+ * }
+ * ```
+ */
+export type { CommandContent, ToolCommandAdapter, GeneratedCommand, } from './types.js';
+export { CommandAdapterRegistry } from './registry.js';
+export { generateCommand, generateCommands } from './generator.js';
+export { claudeAdapter, opencodeAdapter } from './adapters/index.js';

package/node_modules/@freeharness/sdd/dist/vendor/openspec/generation/command-generation/index.js

@@ -0,0 +1,25 @@
+/**
+ * Command Generation Module
+ *
+ * Generic command generation system with tool-specific adapters.
+ *
+ * FreeHarness trim: adapter re-export reduced to claude + opencode.
+ *
+ * Usage:
+ * ```typescript
+ * import { generateCommands, CommandAdapterRegistry, type CommandContent } from './command-generation/index.js';
+ *
+ * const contents: CommandContent[] = [...];
+ * const adapter = CommandAdapterRegistry.get('claude');
+ * if (adapter) {
+ *   const commands = generateCommands(contents, adapter);
+ *   // Write commands to disk
+ * }
+ * ```
+ */
+// Registry
+export { CommandAdapterRegistry } from './registry.js';
+// Generator functions
+export { generateCommand, generateCommands } from './generator.js';
+// Adapters (for direct access if needed)
+export { claudeAdapter, opencodeAdapter } from './adapters/index.js';