freeharness 0.4.1

package/node_modules/@freeharness/sdd/dist/vendor/openspec/engine/global-config.d.ts

@@ -0,0 +1,15 @@
+export declare const GLOBAL_DATA_DIR_NAME = "openspec";
+export interface GlobalDataDirOptions {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    homedir?: string;
+}
+/**
+ * Gets the global data directory path following the XDG Base Directory
+ * Specification. Used for user data like schema overrides.
+ *
+ * - All platforms: $XDG_DATA_HOME/openspec/ if XDG_DATA_HOME is set
+ * - Unix/macOS fallback: ~/.local/share/openspec/
+ * - Windows fallback: %LOCALAPPDATA%/openspec/
+ */
+export declare function getGlobalDataDir(options?: GlobalDataDirOptions): string;

package/node_modules/@freeharness/sdd/dist/vendor/openspec/engine/global-config.js

@@ -0,0 +1,49 @@
+// Store-free replacement for @fission-ai/openspec@1.8.0 src/core/global-config.ts.
+//
+// PATCH: the schema-validation slice only needs getGlobalDataDir() to locate the
+// user's schema-override directory. The upstream file additionally carries config
+// load/save and (in the fork) the multi-repo ~/.openspec store + worksets plumbing.
+// None of that belongs in this slice, so this trimmed module exposes ONLY the
+// XDG-based data-dir resolver, preserving upstream's exact resolution logic:
+//   ${XDG_DATA_HOME}/openspec  ->  else per-platform default:
+//     unix/macOS: ~/.local/share/openspec
+//     win32:      %LOCALAPPDATA%/openspec (or ~/AppData/Local/openspec)
+// No ~/.openspec store, no worksets.
+import * as path from 'node:path';
+import * as os from 'node:os';
+// Constant kept identical to upstream.
+export const GLOBAL_DATA_DIR_NAME = 'openspec';
+function joinGlobalDataPath(platform, ...segments) {
+    return platform === 'win32'
+        ? path.win32.join(...segments)
+        : path.posix.join(...segments);
+}
+/**
+ * Gets the global data directory path following the XDG Base Directory
+ * Specification. Used for user data like schema overrides.
+ *
+ * - All platforms: $XDG_DATA_HOME/openspec/ if XDG_DATA_HOME is set
+ * - Unix/macOS fallback: ~/.local/share/openspec/
+ * - Windows fallback: %LOCALAPPDATA%/openspec/
+ */
+export function getGlobalDataDir(options = {}) {
+    const env = options.env ?? process.env;
+    const platform = options.platform ?? os.platform();
+    // XDG_DATA_HOME takes precedence on all platforms when explicitly set
+    const xdgDataHome = env.XDG_DATA_HOME;
+    if (xdgDataHome) {
+        return joinGlobalDataPath(platform, xdgDataHome, GLOBAL_DATA_DIR_NAME);
+    }
+    const homedir = options.homedir ?? os.homedir();
+    if (platform === 'win32') {
+        // Windows: use %LOCALAPPDATA%
+        const localAppData = env.LOCALAPPDATA;
+        if (localAppData) {
+            return joinGlobalDataPath(platform, localAppData, GLOBAL_DATA_DIR_NAME);
+        }
+        // Fallback for Windows if LOCALAPPDATA is not set
+        return joinGlobalDataPath(platform, homedir, 'AppData', 'Local', GLOBAL_DATA_DIR_NAME);
+    }
+    // Unix/macOS fallback: ~/.local/share
+    return joinGlobalDataPath(platform, homedir, '.local', 'share', GLOBAL_DATA_DIR_NAME);
+}

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

@@ -0,0 +1,71 @@
+import type { Artifact, SchemaYaml, CompletedSet, BlockedArtifacts } from './types.js';
+/**
+ * Represents an artifact dependency graph.
+ * Provides methods for querying build order, ready artifacts, and completion status.
+ */
+export declare class ArtifactGraph {
+    private artifacts;
+    private schema;
+    /** Artifact id -> its position in the schema's `artifacts:` list. */
+    private declarationOrder;
+    private constructor();
+    /**
+     * Orders artifact ids by where the schema declares them.
+     *
+     * The dependency graph leaves siblings tied - spec-driven's `specs` and
+     * `design` both require only `proposal`, so both become ready at the same
+     * time. Ties used to be broken alphabetically, which put `design` ahead of
+     * `specs` and made the CLI recommend the artifacts in an order that
+     * contradicted the schema's own documented sequence
+     * (proposal -> specs -> design -> tasks). Breaking ties by declaration order
+     * follows the sequence the schema author wrote, for built-in and custom
+     * schemas alike, and stays just as deterministic. Ids not in the schema sort
+     * last so the comparator stays total.
+     */
+    private compareByDeclarationOrder;
+    /**
+     * Creates an ArtifactGraph from a YAML file path.
+     */
+    static fromYaml(filePath: string): ArtifactGraph;
+    /**
+     * Creates an ArtifactGraph from YAML content string.
+     */
+    static fromYamlContent(yamlContent: string): ArtifactGraph;
+    /**
+     * Creates an ArtifactGraph from a pre-validated schema object.
+     */
+    static fromSchema(schema: SchemaYaml): ArtifactGraph;
+    /**
+     * Gets a single artifact by ID.
+     */
+    getArtifact(id: string): Artifact | undefined;
+    /**
+     * Gets all artifacts in the graph.
+     */
+    getAllArtifacts(): Artifact[];
+    /**
+     * Gets the schema name.
+     */
+    getName(): string;
+    /**
+     * Gets the schema version.
+     */
+    getVersion(): number;
+    /**
+     * Computes the topological build order using Kahn's algorithm.
+     * Returns artifact IDs in the order they should be built.
+     */
+    getBuildOrder(): string[];
+    /**
+     * Gets artifacts that are ready to be created (all dependencies completed).
+     */
+    getNextArtifacts(completed: CompletedSet): string[];
+    /**
+     * Checks if all artifacts in the graph are completed.
+     */
+    isComplete(completed: CompletedSet): boolean;
+    /**
+     * Gets blocked artifacts and their unmet dependencies.
+     */
+    getBlocked(completed: CompletedSet): BlockedArtifacts;
+}

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

@@ -0,0 +1,164 @@
+import { loadSchema, parseSchema } from './schema.js';
+/**
+ * Represents an artifact dependency graph.
+ * Provides methods for querying build order, ready artifacts, and completion status.
+ */
+export class ArtifactGraph {
+    artifacts;
+    schema;
+    /** Artifact id -> its position in the schema's `artifacts:` list. */
+    declarationOrder;
+    constructor(schema) {
+        this.schema = schema;
+        this.artifacts = new Map(schema.artifacts.map(a => [a.id, a]));
+        this.declarationOrder = new Map(schema.artifacts.map((a, index) => [a.id, index]));
+    }
+    /**
+     * Orders artifact ids by where the schema declares them.
+     *
+     * The dependency graph leaves siblings tied - spec-driven's `specs` and
+     * `design` both require only `proposal`, so both become ready at the same
+     * time. Ties used to be broken alphabetically, which put `design` ahead of
+     * `specs` and made the CLI recommend the artifacts in an order that
+     * contradicted the schema's own documented sequence
+     * (proposal -> specs -> design -> tasks). Breaking ties by declaration order
+     * follows the sequence the schema author wrote, for built-in and custom
+     * schemas alike, and stays just as deterministic. Ids not in the schema sort
+     * last so the comparator stays total.
+     */
+    compareByDeclarationOrder(a, b) {
+        return ((this.declarationOrder.get(a) ?? Number.MAX_SAFE_INTEGER) -
+            (this.declarationOrder.get(b) ?? Number.MAX_SAFE_INTEGER));
+    }
+    /**
+     * Creates an ArtifactGraph from a YAML file path.
+     */
+    static fromYaml(filePath) {
+        const schema = loadSchema(filePath);
+        return new ArtifactGraph(schema);
+    }
+    /**
+     * Creates an ArtifactGraph from YAML content string.
+     */
+    static fromYamlContent(yamlContent) {
+        const schema = parseSchema(yamlContent);
+        return new ArtifactGraph(schema);
+    }
+    /**
+     * Creates an ArtifactGraph from a pre-validated schema object.
+     */
+    static fromSchema(schema) {
+        return new ArtifactGraph(schema);
+    }
+    /**
+     * Gets a single artifact by ID.
+     */
+    getArtifact(id) {
+        return this.artifacts.get(id);
+    }
+    /**
+     * Gets all artifacts in the graph.
+     */
+    getAllArtifacts() {
+        return Array.from(this.artifacts.values());
+    }
+    /**
+     * Gets the schema name.
+     */
+    getName() {
+        return this.schema.name;
+    }
+    /**
+     * Gets the schema version.
+     */
+    getVersion() {
+        return this.schema.version;
+    }
+    /**
+     * Computes the topological build order using Kahn's algorithm.
+     * Returns artifact IDs in the order they should be built.
+     */
+    getBuildOrder() {
+        const inDegree = new Map();
+        const dependents = new Map();
+        // Initialize all artifacts
+        for (const artifact of this.artifacts.values()) {
+            inDegree.set(artifact.id, artifact.requires.length);
+            dependents.set(artifact.id, []);
+        }
+        // Build reverse adjacency (who depends on whom)
+        for (const artifact of this.artifacts.values()) {
+            for (const req of artifact.requires) {
+                dependents.get(req).push(artifact.id);
+            }
+        }
+        // Start with roots (in-degree 0), in declaration order for determinism
+        const queue = [...this.artifacts.keys()]
+            .filter(id => inDegree.get(id) === 0)
+            .sort((a, b) => this.compareByDeclarationOrder(a, b));
+        const result = [];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            result.push(current);
+            // Collect newly ready artifacts, then sort before adding
+            const newlyReady = [];
+            for (const dep of dependents.get(current)) {
+                const newDegree = inDegree.get(dep) - 1;
+                inDegree.set(dep, newDegree);
+                if (newDegree === 0) {
+                    newlyReady.push(dep);
+                }
+            }
+            // Re-sort the whole queue, not just the new arrivals: an artifact that
+            // has been waiting can be declared after one that just became ready.
+            queue.push(...newlyReady);
+            queue.sort((a, b) => this.compareByDeclarationOrder(a, b));
+        }
+        return result;
+    }
+    /**
+     * Gets artifacts that are ready to be created (all dependencies completed).
+     */
+    getNextArtifacts(completed) {
+        const ready = [];
+        for (const artifact of this.artifacts.values()) {
+            if (completed.has(artifact.id)) {
+                continue; // Already completed
+            }
+            const allDepsCompleted = artifact.requires.every(req => completed.has(req));
+            if (allDepsCompleted) {
+                ready.push(artifact.id);
+            }
+        }
+        // Declaration order: deterministic, and the first entry is the artifact the
+        // schema wants written next.
+        return ready.sort((a, b) => this.compareByDeclarationOrder(a, b));
+    }
+    /**
+     * Checks if all artifacts in the graph are completed.
+     */
+    isComplete(completed) {
+        for (const artifact of this.artifacts.values()) {
+            if (!completed.has(artifact.id)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Gets blocked artifacts and their unmet dependencies.
+     */
+    getBlocked(completed) {
+        const blocked = {};
+        for (const artifact of this.artifacts.values()) {
+            if (completed.has(artifact.id)) {
+                continue; // Already completed
+            }
+            const unmetDeps = artifact.requires.filter(req => !completed.has(req));
+            if (unmetDeps.length > 0) {
+                blocked[artifact.id] = unmetDeps.sort((a, b) => this.compareByDeclarationOrder(a, b));
+            }
+        }
+        return blocked;
+    }
+}

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

@@ -0,0 +1,11 @@
+export { ArtifactSchema, SchemaYamlSchema, type Artifact, type SchemaYaml, type CompletedSet, type BlockedArtifacts, } from './types.js';
+export { loadSchema, parseSchema, SchemaValidationError } from './schema.js';
+export { resolveSchema, listSchemas, listSchemasWithInfo, getSchemaDir, getPackageSchemasDir, getUserSchemasDir, getProjectSchemasDir, SchemaLoadError, type SchemaInfo, } from './resolver.js';
+export { getGlobalDataDir } from './global-config.js';
+export { ArtifactGraph } from './graph.js';
+export { detectCompleted } from './state.js';
+export { artifactOutputExists, isGlobPattern, resolveArtifactOutputPath, resolveArtifactOutputs, } from './outputs.js';
+export { readChangeMetadata, resolveSchemaForChange, writeChangeMetadata, ChangeMetadataSchema, ChangeMetadataError, METADATA_FILENAME, type ChangeMetadata, } from './change-metadata.js';
+export { loadTemplate, loadChangeContext, generateInstructions, formatChangeStatus, TemplateLoadError, SKIP_SPECS_INSTRUCTIONS_WARNING, type ChangeContext, type LoadChangeContextOptions, type ArtifactInstructions, type DependencyInfo, type ArtifactStatus, type ChangeStatus, type ArtifactPathSummary, } from './instruction-loader.js';
+export { getTaskProgressForChange, parseTaskLines, countTasksFromContent, formatTaskStatus, type TaskProgress, type ParsedTask, } from './task-progress.js';
+export { buildActionContext, buildNextSteps, type ActionContext, } from './change-status-policy.js';

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

@@ -0,0 +1,21 @@
+// Barrel for the vendored artifact-graph engine slice.
+// P3 inc.1 shipped schema/resolver/types only; P3 inc.4 adds the rest of the
+// engine (graph/state/outputs + a store-free instruction-loader) so the CLI
+// shim's `status`/`instructions`/`list` run entirely on vendored code.
+export { ArtifactSchema, SchemaYamlSchema, } from './types.js';
+export { loadSchema, parseSchema, SchemaValidationError } from './schema.js';
+export { resolveSchema, listSchemas, listSchemasWithInfo, getSchemaDir, getPackageSchemasDir, getUserSchemasDir, getProjectSchemasDir, SchemaLoadError, } from './resolver.js';
+export { getGlobalDataDir } from './global-config.js';
+// Graph operations
+export { ArtifactGraph } from './graph.js';
+// State detection
+export { detectCompleted } from './state.js';
+export { artifactOutputExists, isGlobPattern, resolveArtifactOutputPath, resolveArtifactOutputs, } from './outputs.js';
+// Change metadata (store-free)
+export { readChangeMetadata, resolveSchemaForChange, writeChangeMetadata, ChangeMetadataSchema, ChangeMetadataError, METADATA_FILENAME, } from './change-metadata.js';
+// Instruction loading + status (store-free)
+export { loadTemplate, loadChangeContext, generateInstructions, formatChangeStatus, TemplateLoadError, SKIP_SPECS_INSTRUCTIONS_WARNING, } from './instruction-loader.js';
+// Task progress (list)
+export { getTaskProgressForChange, parseTaskLines, countTasksFromContent, formatTaskStatus, } from './task-progress.js';
+// Change-status policy
+export { buildActionContext, buildNextSteps, } from './change-status-policy.js';

package/node_modules/@freeharness/sdd/dist/vendor/openspec/engine/instruction-loader.d.ts

@@ -0,0 +1,102 @@
+import { ArtifactGraph } from './graph.js';
+import { type ChangeMetadata } from './change-metadata.js';
+import { type ActionContext } from './change-status-policy.js';
+import type { CompletedSet } from './types.js';
+/**
+ * Error thrown when loading a template fails.
+ */
+export declare class TemplateLoadError extends Error {
+    readonly templatePath: string;
+    constructor(message: string, templatePath: string);
+}
+/**
+ * Change context containing graph, completion state, and metadata.
+ */
+export interface ChangeContext {
+    graph: ArtifactGraph;
+    completed: CompletedSet;
+    schemaName: string;
+    changeName: string;
+    changeDir: string;
+    projectRoot: string;
+    metadata?: ChangeMetadata;
+    /**
+     * Artifact IDs counted as complete only because the change declares
+     * skip_specs, not because their files exist. Kept separate so status can
+     * render them as skipped rather than done.
+     */
+    skippedArtifacts?: Set<string>;
+}
+export interface LoadChangeContextOptions {
+    changeDir?: string;
+}
+/**
+ * The do-not-create signal attached to a skipped (skip_specs) artifact.
+ */
+export declare const SKIP_SPECS_INSTRUCTIONS_WARNING: string;
+export interface DependencyInfo {
+    id: string;
+    done: boolean;
+    path: string;
+    description: string;
+    skipped?: boolean;
+}
+export interface ArtifactInstructions {
+    changeName: string;
+    artifactId: string;
+    schemaName: string;
+    changeDir: string;
+    outputPath: string;
+    resolvedOutputPath: string;
+    existingOutputPaths: string[];
+    description: string;
+    instruction: string | undefined;
+    template: string;
+    dependencies: DependencyInfo[];
+    unlocks: string[];
+    skipped?: boolean;
+    warning?: string;
+}
+export interface ArtifactStatus {
+    id: string;
+    outputPath: string;
+    status: 'done' | 'skipped' | 'ready' | 'blocked';
+    requires: string[];
+    missingDeps?: string[];
+}
+export interface ArtifactPathSummary {
+    outputPath: string;
+    resolvedOutputPath: string;
+    existingOutputPaths: string[];
+}
+export interface ChangeStatus {
+    changeName: string;
+    schemaName: string;
+    changeRoot: string;
+    artifactPaths: Record<string, ArtifactPathSummary>;
+    nextSteps: string[];
+    actionContext: ActionContext;
+    isPlanningComplete: boolean;
+    isComplete: boolean;
+    applyRequires: string[];
+    artifacts: ArtifactStatus[];
+}
+/**
+ * Loads a template from a schema's templates directory.
+ */
+export declare function loadTemplate(schemaName: string, templatePath: string, projectRoot?: string): string;
+/**
+ * Loads change context combining graph and completion state.
+ *
+ * Schema resolution order: explicit override -> `.openspec.yaml` metadata ->
+ * 'spec-driven'.
+ */
+export declare function loadChangeContext(projectRoot: string, changeName: string, schemaName?: string, options?: LoadChangeContextOptions): ChangeContext;
+/**
+ * Generates enriched instructions for creating an artifact.
+ */
+export declare function generateInstructions(context: ChangeContext, artifactId: string): ArtifactInstructions;
+/**
+ * Formats the status of all artifacts in a change.
+ */
+export declare function formatChangeStatus(context: ChangeContext): ChangeStatus;

package/node_modules/@freeharness/sdd/dist/vendor/openspec/engine/instruction-loader.js

@@ -0,0 +1,230 @@
+// RECONSTRUCTED (store-free) from @fission-ai/openspec@1.8.0
+//   src/core/artifact-graph/instruction-loader.ts
+//
+// The upstream loader couples artifact instructions/status to a large store
+// stack: project-config (context/rules), the referenced-store index, the
+// multi-repo planning home, and the change-metadata/project-config schema
+// fallback. This slice keeps the artifact-graph behaviour the /opsx skills
+// depend on and drops the store coupling:
+//   - loadChangeContext / generateInstructions / formatChangeStatus preserve
+//     their output shapes for the fields the skills read (artifacts[].status,
+//     artifacts[].requires, applyRequires, isPlanningComplete/isComplete,
+//     dependencies, unlocks, template, skip_specs handling).
+//   - DROPPED vs upstream: `planningHome`, `references`, config-driven
+//     `context`/`rules`, and the config.yaml schema fallback. These are
+//     store/config surfaces outside the vendored slice.
+// skip_specs handling and the declaration-order build sequence are faithful.
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getSchemaDir, resolveSchema } from './resolver.js';
+import { ArtifactGraph } from './graph.js';
+import { detectCompleted } from './state.js';
+import { resolveArtifactOutputPath, resolveArtifactOutputs } from './outputs.js';
+import { readChangeMetadata, resolveSchemaForChange } from './change-metadata.js';
+import { FileSystemUtils } from './file-system.js';
+import { buildActionContext, buildNextSteps, } from './change-status-policy.js';
+/**
+ * Error thrown when loading a template fails.
+ */
+export class TemplateLoadError extends Error {
+    templatePath;
+    constructor(message, templatePath) {
+        super(message);
+        this.templatePath = templatePath;
+        this.name = 'TemplateLoadError';
+    }
+}
+/**
+ * The do-not-create signal attached to a skipped (skip_specs) artifact.
+ */
+export const SKIP_SPECS_INSTRUCTIONS_WARNING = 'This change declares skip_specs: true in .openspec.yaml (no spec-level behavior changes), so this artifact is skipped.\n' +
+    'Do not create spec files - they will conflict with that marker. If requirements now change, remove skip_specs from .openspec.yaml and rerun this command.';
+/**
+ * Loads a template from a schema's templates directory.
+ */
+export function loadTemplate(schemaName, templatePath, projectRoot) {
+    const schemaDir = getSchemaDir(schemaName, projectRoot);
+    if (!schemaDir) {
+        throw new TemplateLoadError(`Schema '${schemaName}' not found`, templatePath);
+    }
+    const templatesDir = path.join(schemaDir, 'templates');
+    const templatePathOnDisk = path.join(templatesDir, templatePath);
+    try {
+        FileSystemUtils.assertPathWithin(templatesDir, templatePathOnDisk);
+    }
+    catch (error) {
+        throw new TemplateLoadError(error instanceof Error ? error.message : String(error), templatePathOnDisk);
+    }
+    if (!fs.existsSync(templatePathOnDisk)) {
+        throw new TemplateLoadError(`Template not found: ${templatePathOnDisk}`, templatePathOnDisk);
+    }
+    try {
+        return fs.readFileSync(templatePathOnDisk, 'utf-8');
+    }
+    catch (err) {
+        const ioError = err instanceof Error ? err : new Error(String(err));
+        throw new TemplateLoadError(`Failed to read template: ${ioError.message}`, templatePathOnDisk);
+    }
+}
+/**
+ * Loads change context combining graph and completion state.
+ *
+ * Schema resolution order: explicit override -> `.openspec.yaml` metadata ->
+ * 'spec-driven'.
+ */
+export function loadChangeContext(projectRoot, changeName, schemaName, options = {}) {
+    const changeDir = options.changeDir ?? path.join(projectRoot, 'openspec', 'changes', changeName);
+    const metadata = readChangeMetadata(changeDir, projectRoot) ?? undefined;
+    const resolvedSchemaName = resolveSchemaForChange(changeDir, schemaName, projectRoot, {
+        metadata: metadata ?? null,
+    });
+    const schema = resolveSchema(resolvedSchemaName, projectRoot);
+    const graph = ArtifactGraph.fromSchema(schema);
+    const completed = detectCompleted(graph, changeDir);
+    // A change that declares skip_specs has no spec deltas by design, so
+    // artifacts generating into specs/ count as complete; tracked separately so
+    // status renders them as skipped, not done.
+    const skippedArtifacts = new Set();
+    if (metadata?.skip_specs) {
+        for (const artifact of graph.getAllArtifacts()) {
+            const generates = artifact.generates.replace(/^(?:\.\/)+/, '');
+            if (generates.startsWith('specs/') && !completed.has(artifact.id)) {
+                completed.add(artifact.id);
+                skippedArtifacts.add(artifact.id);
+            }
+        }
+    }
+    return {
+        graph,
+        completed,
+        schemaName: resolvedSchemaName,
+        changeName,
+        changeDir,
+        projectRoot,
+        ...(metadata ? { metadata } : {}),
+        ...(skippedArtifacts.size > 0 ? { skippedArtifacts } : {}),
+    };
+}
+/**
+ * Generates enriched instructions for creating an artifact.
+ */
+export function generateInstructions(context, artifactId) {
+    const artifact = context.graph.getArtifact(artifactId);
+    if (!artifact) {
+        throw new Error(`Artifact '${artifactId}' not found in schema '${context.schemaName}'`);
+    }
+    const templateContent = loadTemplate(context.schemaName, artifact.template, context.projectRoot);
+    const dependencies = getDependencyInfo(artifact, context.graph, context.completed, context.skippedArtifacts);
+    const unlocks = getUnlockedArtifacts(context.graph, artifactId);
+    return {
+        changeName: context.changeName,
+        artifactId: artifact.id,
+        schemaName: context.schemaName,
+        changeDir: context.changeDir,
+        outputPath: artifact.generates,
+        resolvedOutputPath: resolveArtifactOutputPath(context.changeDir, artifact.generates),
+        existingOutputPaths: resolveArtifactOutputs(context.changeDir, artifact.generates),
+        description: artifact.description,
+        instruction: artifact.instruction,
+        ...(context.skippedArtifacts?.has(artifact.id)
+            ? { skipped: true, warning: SKIP_SPECS_INSTRUCTIONS_WARNING }
+            : {}),
+        template: templateContent,
+        dependencies,
+        unlocks,
+    };
+}
+function getDependencyInfo(artifact, graph, completed, skippedArtifacts) {
+    return artifact.requires.map((id) => {
+        const depArtifact = graph.getArtifact(id);
+        return {
+            id,
+            done: completed.has(id),
+            path: depArtifact?.generates ?? id,
+            description: depArtifact?.description ?? '',
+            ...(skippedArtifacts?.has(id) ? { skipped: true } : {}),
+        };
+    });
+}
+function getUnlockedArtifacts(graph, artifactId) {
+    const unlocks = [];
+    for (const artifact of graph.getAllArtifacts()) {
+        if (artifact.requires.includes(artifactId)) {
+            unlocks.push(artifact.id);
+        }
+    }
+    return unlocks;
+}
+/**
+ * Formats the status of all artifacts in a change.
+ */
+export function formatChangeStatus(context) {
+    const schema = resolveSchema(context.schemaName, context.projectRoot);
+    const applyRequires = schema.apply?.requires ?? schema.artifacts.map((a) => a.id);
+    const artifacts = context.graph.getAllArtifacts();
+    const ready = new Set(context.graph.getNextArtifacts(context.completed));
+    const blocked = context.graph.getBlocked(context.completed);
+    const artifactPaths = {};
+    const artifactStatuses = artifacts.map((artifact) => {
+        artifactPaths[artifact.id] = {
+            outputPath: artifact.generates,
+            resolvedOutputPath: resolveArtifactOutputPath(context.changeDir, artifact.generates),
+            existingOutputPaths: resolveArtifactOutputs(context.changeDir, artifact.generates),
+        };
+        if (context.skippedArtifacts?.has(artifact.id)) {
+            return {
+                id: artifact.id,
+                outputPath: artifact.generates,
+                status: 'skipped',
+                requires: artifact.requires,
+            };
+        }
+        if (context.completed.has(artifact.id)) {
+            return {
+                id: artifact.id,
+                outputPath: artifact.generates,
+                status: 'done',
+                requires: artifact.requires,
+            };
+        }
+        if (ready.has(artifact.id)) {
+            return {
+                id: artifact.id,
+                outputPath: artifact.generates,
+                status: 'ready',
+                requires: artifact.requires,
+            };
+        }
+        return {
+            id: artifact.id,
+            outputPath: artifact.generates,
+            status: 'blocked',
+            requires: artifact.requires,
+            missingDeps: blocked[artifact.id] ?? [],
+        };
+    });
+    const buildOrder = context.graph.getBuildOrder();
+    const orderMap = new Map(buildOrder.map((id, idx) => [id, idx]));
+    artifactStatuses.sort((a, b) => (orderMap.get(a.id) ?? 0) - (orderMap.get(b.id) ?? 0));
+    const isComplete = context.graph.isComplete(context.completed);
+    const artifactIds = artifactStatuses.map((artifact) => artifact.id);
+    return {
+        changeName: context.changeName,
+        schemaName: context.schemaName,
+        changeRoot: context.changeDir,
+        artifactPaths,
+        isPlanningComplete: isComplete,
+        isComplete,
+        applyRequires,
+        nextSteps: buildNextSteps({
+            changeName: context.changeName,
+            artifactStatuses,
+            allArtifactsComplete: isComplete,
+        }),
+        actionContext: buildActionContext({
+            projectRoot: context.projectRoot,
+            artifactIds,
+        }),
+        artifacts: artifactStatuses,
+    };
+}