gmc-openspec 1.1.0 → 1.4.1

package/dist/commands/workspace.js

@@ -1,37 +1,18 @@
 import chalk from 'chalk';
-import * as nodeFs from 'node:fs';
-import * as path from 'node:path';
-import { createWorkspaceSkillSkippedReport, generateWorkspaceAgentSkills, getDefaultWorkspaceOpenerChoiceValue, getWorkspaceSkillCapableTools, getWorkspaceSkillToolIds, getWorkspaceOpenerLabel, isWorkspaceAgentOpenerId, listWorkspaceOpenerChoices, parseWorkspacePreferredOpenerValue, parseWorkspaceSkillToolsValue, updateWorkspaceAgentSkills, listWorkspaceRegistryEntries, readOptionalWorkspaceLocalState, writeWorkspaceLocalState, } from '../core/workspace/index.js';
+import { createWorkspaceSkillSkippedReport, generateWorkspaceAgentSkills, getWorkspaceSkillCapableTools, getWorkspaceSkillToolIds, getWorkspaceOpenerLabel, parseWorkspaceSkillToolsValue, updateWorkspaceAgentSkills, listKnownWorkspaceEntries, readWorkspaceViewState, syncWorkspaceOpenSurface, writeWorkspaceViewState, } from '../core/workspace/index.js';
 import { isInteractive, resolveNoInteractive } from '../utils/interactive.js';
-import { addWorkspaceLink, createManagedWorkspace, inferLinkName, loadWorkspaceForDoctor, loadWorkspaceForList, parseSetupLinks, readWorkspaceForMutation, readRegistry, recordSelectedWorkspaceAfterMutation, resolveExistingDirectory, updateWorkspaceLink, validateLinkNameForCommand, validateWorkspaceNameForSetup, } from './workspace/operations.js';
+import { addWorkspaceLink, createManagedWorkspace, loadWorkspaceForDoctor, loadWorkspaceForList, parseSetupLinks, readWorkspaceForMutation, updateWorkspaceLink, validateWorkspaceNameForSetup, } from './workspace/operations.js';
 import { selectWorkspaceForCommand, selectWorkspaceRootForCommand, } from './workspace/selection.js';
-import { assertWorkspaceOpenerAvailable, buildWorkspaceOpenCommandForState, launchWorkspaceOpenCommand, readWorkspaceOpenState, } from './workspace/open.js';
+import { launchWorkspaceOpenCommand, } from './workspace/open.js';
+import { buildWorkspaceOpenJsonPayload, prepareWorkspaceOpen, } from './workspace/open-view.js';
+import { getPreferredWorkspaceSkillAgentId, parseSetupOpenerOption, promptPreferredOpener, } from './workspace/opener-selection.js';
+import { workspacePromptTheme } from './workspace/prompt-theme.js';
+import { registerWorkspaceCommandWith } from './workspace/registration.js';
+import { promptSetupLinks } from './workspace/setup-prompts.js';
 import { WorkspaceCliError, appendStatus, asErrorMessage, asStatus, } from './workspace/types.js';
 function printJson(payload) {
     console.log(JSON.stringify(payload, null, 2));
 }
-const workspacePromptTheme = {
-    prefix: '',
-    style: {
-        answer: (text) => chalk.cyan(text),
-        defaultAnswer: (text) => chalk.dim(text),
-        error: (text) => chalk.red(text),
-        help: (text) => chalk.dim(text),
-        highlight: (text) => chalk.cyan(text),
-        key: (text) => chalk.cyan(text),
-        message: (text) => chalk.bold(text),
-    },
-};
-const workspaceSelectTheme = {
-    ...workspacePromptTheme,
-    icon: {
-        cursor: chalk.cyan('>'),
-    },
-    style: {
-        ...workspacePromptTheme.style,
-        keysHelpTip: (keys) => chalk.dim(keys.map(([key, action]) => `${key}: ${action}`).join(' | ')),
-    },
-};
 function printWorkspaceSetupIntro() {
     console.log(chalk.bold('Workspace setup'));
     console.log('');
@@ -63,125 +44,6 @@ async function promptWorkspaceName(initialName) {
         },
     });
 }
-async function promptExistingPath(message, defaultPath) {
-    const { input } = await import('@inquirer/prompts');
-    const pathInput = await input({
-        message,
-        default: defaultPath,
-        prefill: defaultPath ? 'editable' : undefined,
-        required: true,
-        theme: workspacePromptTheme,
-        validate(value) {
-            const resolvedPath = path.isAbsolute(value)
-                ? path.resolve(value)
-                : path.resolve(process.cwd(), value);
-            return nodeFs.existsSync(resolvedPath) && nodeFs.statSync(resolvedPath).isDirectory()
-                ? true
-                : 'Enter an existing repo or folder path.';
-        },
-    });
-    return resolveExistingDirectory(pathInput);
-}
-async function promptLinkName(existingLinks) {
-    const { input } = await import('@inquirer/prompts');
-    return input({
-        message: 'Link name:',
-        required: true,
-        theme: workspacePromptTheme,
-        validate(value) {
-            try {
-                validateLinkNameForCommand(value);
-            }
-            catch (error) {
-                return asErrorMessage(error);
-            }
-            if (existingLinks[value]) {
-                return `Link name '${value}' is already linked to ${existingLinks[value]}.`;
-            }
-            return true;
-        },
-    });
-}
-async function promptSetupLinks() {
-    const { select } = await import('@inquirer/prompts');
-    const links = {};
-    console.log('');
-    console.log(chalk.bold('[2/5] Link repos or folders'));
-    console.log(chalk.dim('Start with the current directory, or enter another repo path.'));
-    console.log('');
-    while (true) {
-        const linkCount = Object.keys(links).length;
-        const resolvedPath = await promptExistingPath(linkCount === 0 ? 'Repo or folder path:' : 'Another repo or folder path:', linkCount === 0 ? '.' : undefined);
-        let linkName = inferLinkName(resolvedPath);
-        try {
-            validateLinkNameForCommand(linkName);
-        }
-        catch {
-            linkName = await promptLinkName(links);
-        }
-        if (links[linkName]) {
-            console.log(`Link name '${linkName}' is already linked to ${links[linkName]}.`);
-            linkName = await promptLinkName(links);
-        }
-        links[linkName] = resolvedPath;
-        console.log(chalk.green(`Added link '${linkName}'`));
-        console.log(chalk.dim(`  ${resolvedPath}`));
-        const nextAction = await select({
-            message: 'Continue',
-            default: 'finish',
-            choices: [
-                {
-                    name: 'Create workspace files',
-                    short: 'Create workspace files',
-                    value: 'finish',
-                    description: 'Run a workspace check after setup',
-                },
-                {
-                    name: 'Add another repo or folder',
-                    short: 'Add another',
-                    value: 'add',
-                    description: 'Include another local directory in this workspace',
-                },
-            ],
-            theme: workspaceSelectTheme,
-        });
-        if (nextAction === 'finish') {
-            return links;
-        }
-    }
-}
-function formatOpenerChoiceName(choice) {
-    return choice.unavailableNote ? `${choice.label} (${choice.unavailableNote})` : choice.label;
-}
-async function promptPreferredOpener(message, openerChoices = listWorkspaceOpenerChoices()) {
-    const { select } = await import('@inquirer/prompts');
-    const selectedValue = await select({
-        message,
-        default: getDefaultWorkspaceOpenerChoiceValue(openerChoices),
-        choices: openerChoices.map((choice) => ({
-            name: formatOpenerChoiceName(choice),
-            short: choice.label,
-            value: choice.value,
-            description: choice.unavailableNote ?? `Use ${choice.label}`,
-        })),
-        theme: workspaceSelectTheme,
-    });
-    return parseWorkspacePreferredOpenerValue(selectedValue);
-}
-function parseSetupOpenerOption(opener) {
-    if (!opener) {
-        return undefined;
-    }
-    try {
-        return parseWorkspacePreferredOpenerValue(opener);
-    }
-    catch (error) {
-        throw new WorkspaceCliError(asErrorMessage(error), 'unsupported_workspace_opener', {
-            target: 'workspace.opener',
-            fix: 'Use --opener codex, --opener claude, --opener github-copilot, or --opener editor.',
-        });
-    }
-}
 function parseSetupToolsOption(tools) {
     try {
         return parseWorkspaceSkillToolsValue(tools);
@@ -204,12 +66,6 @@ function parseUpdateToolsOption(tools) {
         });
     }
 }
-function getPreferredWorkspaceSkillAgentId(preferredOpener) {
-    if (!preferredOpener || preferredOpener.kind !== 'agent') {
-        return null;
-    }
-    return getWorkspaceSkillToolIds().includes(preferredOpener.id) ? preferredOpener.id : null;
-}
 async function promptWorkspaceSkillAgents(preferredOpener) {
     const { searchableMultiSelect } = await import('../prompts/searchable-multi-select.js');
     const preferredAgentId = getPreferredWorkspaceSkillAgentId(preferredOpener);
@@ -238,18 +94,6 @@ async function promptWorkspaceSkillAgents(preferredOpener) {
         choices: sortedChoices,
     });
 }
-function parseAgentOverride(agent) {
-    if (!isWorkspaceAgentOpenerId(agent)) {
-        throw new WorkspaceCliError(`Unsupported workspace agent '${agent}'. Supported agents: codex, claude, github-copilot.`, 'unsupported_workspace_agent', {
-            target: 'workspace.opener',
-            fix: 'Use --agent codex, --agent claude, or --agent github-copilot.',
-        });
-    }
-    return {
-        kind: 'agent',
-        id: agent,
-    };
-}
 function printStatusLines(statuses) {
     for (const status of statuses) {
         const label = status.severity === 'warning' ? 'Warning' : 'Issue';
@@ -281,7 +125,14 @@ function collectWorkspaceIssues(workspace) {
 function printDoctorHuman(result) {
     console.log(`Workspace: ${result.workspace.name}`);
     console.log(`Location: ${result.workspace.root}`);
-    console.log(`Planning path: ${result.workspace.planning_path}`);
+    if (result.workspace.context) {
+        const selector = result.workspace.context.store_selector;
+        const suffix = selector.kind === 'path' ? ` via ${selector.path}` : '';
+        console.log(`Context: ${result.workspace.context.store}/${result.workspace.context.initiative}${suffix}`);
+    }
+    else {
+        console.log('Context: (none)');
+    }
     console.log('');
     printStatusLines(result.status);
     if (result.status.length > 0) {
@@ -290,6 +141,15 @@ function printDoctorHuman(result) {
     console.log('Linked repos or folders:');
     printLinksHuman(result.workspace.links);
     const issues = collectWorkspaceIssues(result.workspace);
+    console.log('');
+    console.log('Advisory edit boundaries:');
+    if (result.workspace.context) {
+        console.log('  Initiative/context-store files are shared coordination context.');
+    }
+    else {
+        console.log('  No initiative coordination context is attached.');
+    }
+    console.log('  Linked repos and folders are local implementation context when selected.');
     if (issues.length === 0) {
         console.log('');
         console.log('No workspace issues found.');
@@ -409,12 +269,9 @@ function setWorkspaceSkillFailureExitCode(report) {
     }
 }
 async function writeWorkspaceSkillState(workspaceRoot, selectedAgentIds, report) {
-    const localState = (await readOptionalWorkspaceLocalState(workspaceRoot)) ?? {
-        version: 1,
-        paths: {},
-    };
-    await writeWorkspaceLocalState(workspaceRoot, {
-        ...localState,
+    const viewState = await readWorkspaceViewState(workspaceRoot);
+    await writeWorkspaceViewState(workspaceRoot, {
+        ...viewState,
         workspace_skills: {
             selected_agents: selectedAgentIds,
             last_applied_profile: report.profile,
@@ -424,66 +281,6 @@ async function writeWorkspaceSkillState(workspaceRoot, selectedAgentIds, report)
         },
     });
 }
-async function resolveWorkspaceOpenOpener(localState, options) {
-    if (options.agent && options.editor) {
-        throw new WorkspaceCliError('workspace open accepts either --agent <tool> or --editor, not both.', 'workspace_opener_conflict', {
-            target: 'workspace.opener',
-            fix: 'Choose one opener override.',
-        });
-    }
-    if (options.agent) {
-        return parseAgentOverride(options.agent);
-    }
-    if (options.editor) {
-        return parseWorkspacePreferredOpenerValue('editor');
-    }
-    if (localState.preferred_opener) {
-        return localState.preferred_opener;
-    }
-    if (!resolveNoInteractive(options) && isInteractive(options)) {
-        const openerChoices = listWorkspaceOpenerChoices().filter((choice) => choice.available);
-        if (openerChoices.length === 0) {
-            throw new WorkspaceCliError('No supported workspace opener is available on PATH.', 'workspace_no_available_openers', {
-                target: 'workspace.opener',
-                fix: "Install VS Code ('code'), Codex ('codex'), or Claude ('claude'), then retry.",
-            });
-        }
-        return promptPreferredOpener('Open with:', openerChoices);
-    }
-    throw new WorkspaceCliError('This workspace does not have a preferred opener yet.', 'workspace_opener_unset', {
-        target: 'workspace.opener',
-        fix: 'Pass --agent <tool> or --editor, or run workspace setup interactively to choose a default opener.',
-    });
-}
-function assertWorkspaceOpenSupportedOptions(options) {
-    if (options.prepareOnly) {
-        throw new WorkspaceCliError('workspace open supports launching through a selected opener; preview output is reserved for a future context/query surface.', 'workspace_open_prepare_only_unsupported', {
-            target: 'workspace.open',
-            fix: 'Run openspec workspace open with --agent <tool> or --editor.',
-        });
-    }
-    if (options.json) {
-        throw new WorkspaceCliError('workspace open supports launching through a selected opener; machine-readable context is reserved for a future context/query surface.', 'workspace_open_json_unsupported', {
-            target: 'workspace.open',
-            fix: 'Use openspec workspace doctor --json for current workspace status.',
-        });
-    }
-    if (options.change) {
-        throw new WorkspaceCliError('workspace open currently supports root workspace open only; change-scoped open belongs to future workspace change planning.', 'workspace_open_change_unsupported', {
-            target: 'workspace.change',
-            fix: 'Open the root workspace, then start implementation from an explicit change workflow.',
-        });
-    }
-}
-function resolveOpenWorkspaceName(positionalName, options) {
-    if (positionalName && options.workspace && positionalName !== options.workspace) {
-        throw new WorkspaceCliError(`Conflicting workspace selectors: positional '${positionalName}' and --workspace '${options.workspace}'.`, 'workspace_selection_conflict', {
-            target: 'workspace.name',
-            fix: 'Use either the positional workspace name or --workspace with the same value.',
-        });
-    }
-    return positionalName ?? options.workspace;
-}
 function resolveUpdateWorkspaceName(positionalName, options) {
     if (positionalName && options.workspace && positionalName !== options.workspace) {
         throw new WorkspaceCliError(`Conflicting workspace selectors: positional '${positionalName}' and --workspace '${options.workspace}'.`, 'workspace_selection_conflict', {
@@ -493,16 +290,20 @@ function resolveUpdateWorkspaceName(positionalName, options) {
     }
     return positionalName ?? options.workspace;
 }
-function printWorkspaceOpenHuman(selectedName, selectedRoot, opener, skipped) {
-    console.log(`Opening workspace: ${selectedName}`);
-    console.log(`Location: ${selectedRoot}`);
-    console.log(`Opener: ${getWorkspaceOpenerLabel(opener)}`);
-    if (skipped.length === 0) {
+function printWorkspaceOpenHuman(prepared) {
+    console.log(`Opening workspace: ${prepared.selected.name}`);
+    console.log(`Location: ${prepared.selected.root}`);
+    if (prepared.initiative) {
+        console.log(`Initiative: ${prepared.initiative.store}/${prepared.initiative.id}`);
+        console.log(`Initiative path: ${prepared.initiative.root}`);
+    }
+    console.log(`Opener: ${getWorkspaceOpenerLabel(prepared.opener)}`);
+    if (prepared.skipped.length === 0) {
         return;
     }
     console.log('');
     console.log('Skipped linked repos or folders:');
-    for (const link of skipped) {
+    for (const link of prepared.skipped) {
         const location = link.path ?? '(no local path recorded)';
         console.log(`  ${link.name} -> ${location}`);
     }
@@ -584,8 +385,6 @@ class WorkspaceCommand {
             console.log('');
             printWorkspaceListHuman([doctorResult.workspace]);
             console.log('');
-            console.log(`Planning path: ${doctorResult.workspace.planning_path}`);
-            console.log('');
             console.log('Workspace check:');
             printWorkspaceCheckSummaryHuman(doctorResult);
             console.log('');
@@ -603,8 +402,7 @@ class WorkspaceCommand {
     }
     async list(options = {}) {
         try {
-            const registry = await readRegistry();
-            const entries = listWorkspaceRegistryEntries(registry);
+            const entries = await listKnownWorkspaceEntries();
             const workspaces = await Promise.all(entries.map((entry) => loadWorkspaceForList(entry)));
             const payload = { workspaces, status: [] };
             if (options.json) {
@@ -696,19 +494,19 @@ class WorkspaceCommand {
         }
     }
     async updateSelected(selected, options) {
-        const { localState } = await readWorkspaceForMutation(selected);
+        const viewState = await readWorkspaceForMutation(selected);
+        await syncWorkspaceOpenSurface(selected.root, viewState);
         const hasExplicitToolSelection = options.tools !== undefined;
         const selectedAgentIds = hasExplicitToolSelection
             ? parseUpdateToolsOption(options.tools ?? '')
-            : localState.workspace_skills?.selected_agents ?? [];
+            : viewState.workspace_skills?.selected_agents ?? [];
         const previousSkillState = hasExplicitToolSelection
-            ? localState.workspace_skills ?? { selected_agents: [] }
-            : localState.workspace_skills;
+            ? viewState.workspace_skills ?? { selected_agents: [] }
+            : viewState.workspace_skills;
         const skillReport = await updateWorkspaceAgentSkills(selected.root, selectedAgentIds, previousSkillState);
-        const shouldStoreSelection = hasExplicitToolSelection || Boolean(localState.workspace_skills);
+        const shouldStoreSelection = hasExplicitToolSelection || Boolean(viewState.workspace_skills);
         if (shouldStoreSelection && !hasWorkspaceSkillFailures(skillReport)) {
             await writeWorkspaceSkillState(selected.root, selectedAgentIds, skillReport);
-            await recordSelectedWorkspaceAfterMutation(selected);
         }
         const doctorResult = await loadWorkspaceForDoctor(selected);
         if (options.json) {
@@ -737,22 +535,20 @@ class WorkspaceCommand {
     }
     async open(positionalName, options = {}) {
         try {
-            assertWorkspaceOpenSupportedOptions(options);
-            const workspaceName = resolveOpenWorkspaceName(positionalName, options);
-            const selected = await selectWorkspaceForCommand({
-                ...options,
-                workspace: workspaceName,
-            }, 'open', { preferPositionalName: true });
-            const state = await readWorkspaceOpenState(selected);
-            const opener = await resolveWorkspaceOpenOpener(state.localState, options);
-            assertWorkspaceOpenerAvailable(opener, state.codeWorkspacePath);
-            const { command, skipped } = await buildWorkspaceOpenCommandForState(opener, selected.root, state);
-            printStatusLines(selected.status);
-            if (selected.status.length > 0) {
-                console.log('');
+            const prepared = await prepareWorkspaceOpen(positionalName, options);
+            if (!options.json) {
+                printStatusLines(prepared.selected.status);
+                if (prepared.selected.status.length > 0) {
+                    console.log('');
+                }
+                printWorkspaceOpenHuman(prepared);
+            }
+            await launchWorkspaceOpenCommand(prepared.command, {
+                stdio: options.json ? 'ignore' : 'inherit',
+            });
+            if (options.json) {
+                printJson(buildWorkspaceOpenJsonPayload(prepared));
             }
-            printWorkspaceOpenHuman(selected.name, selected.root, opener, skipped);
-            await launchWorkspaceOpenCommand(command);
         }
         catch (error) {
             this.handleFailure(options.json, { workspace: null, status: [] }, error);
@@ -785,84 +581,7 @@ export async function runWorkspaceUpdateForRoot(workspaceRoot, options = {}) {
     const workspaceCommand = new WorkspaceCommand();
     await workspaceCommand.updateRoot(workspaceRoot, options);
 }
-function collectOption(value, previous) {
-    return [...previous, value];
-}
-function addWorkspaceSelectionOptions(command) {
-    return command
-        .option('--workspace <name>', 'Workspace name from the local workspace registry')
-        .option('--json', 'Output as JSON')
-        .option('--no-interactive', 'Disable prompts');
-}
 export function registerWorkspaceCommand(program) {
-    const workspaceCommand = new WorkspaceCommand();
-    const workspace = program
-        .command('workspace')
-        .description('Set up and inspect coordination workspaces');
-    workspace
-        .command('setup')
-        .description('Set up a workspace and link existing repos or folders')
-        .option('--name <name>', 'Workspace name')
-        .option('--link <link>', 'Repo or folder link. Use <path> or <name>=<path>.', collectOption, [])
-        .option('--opener <id>', 'Preferred opener: codex, claude, github-copilot, or editor')
-        .option('--tools <tools>', `Install OpenSpec skills for agents. Use "all", "none", or a comma-separated list of: ${getWorkspaceSkillToolIds().join(', ')}`)
-        .option('--json', 'Output as JSON')
-        .option('--no-interactive', 'Disable prompts')
-        .action(async (options) => {
-        await workspaceCommand.setup(options);
-    });
-    workspace
-        .command('list')
-        .description('List known OpenSpec workspaces')
-        .option('--json', 'Output as JSON')
-        .action(async (options) => {
-        await workspaceCommand.list(options);
-    });
-    workspace
-        .command('ls')
-        .description('List known OpenSpec workspaces')
-        .option('--json', 'Output as JSON')
-        .action(async (options) => {
-        await workspaceCommand.list(options);
-    });
-    addWorkspaceSelectionOptions(workspace
-        .command('link [nameOrPath] [path]')
-        .description('Link an existing repo or folder to a workspace')).action(async (nameOrPath, linkPath, options) => {
-        await workspaceCommand.link(nameOrPath, linkPath, options);
-    });
-    addWorkspaceSelectionOptions(workspace
-        .command('relink <name> <path>')
-        .description('Update the local path for an existing workspace link')).action(async (linkName, linkPath, options) => {
-        await workspaceCommand.relink(linkName, linkPath, options);
-    });
-    addWorkspaceSelectionOptions(workspace
-        .command('doctor')
-        .description('Check what a workspace can resolve on this machine')).action(async (options) => {
-        await workspaceCommand.doctor(options);
-    });
-    workspace
-        .command('update [name]')
-        .description('Refresh workspace-local OpenSpec agent skills from the active global profile')
-        .option('--workspace <name>', 'Workspace name from the local workspace registry')
-        .option('--tools <tools>', `Select agents for workspace skills. Use "all", "none", or a comma-separated list of: ${getWorkspaceSkillToolIds().join(', ')}. Global profile selects workflows; --tools selects agents.`)
-        .option('--json', 'Output as JSON')
-        .option('--no-interactive', 'Disable prompts')
-        .action(async (name, options) => {
-        await workspaceCommand.update(name, options);
-    });
-    workspace
-        .command('open [name]')
-        .description('Open a workspace in an agent or VS Code editor')
-        .option('--workspace <name>', 'Workspace name from the local workspace registry')
-        .option('--agent <tool>', 'Use an agent for this session: codex, claude, or github-copilot')
-        .option('--editor', 'Open the workspace in VS Code editor mode')
-        .option('--prepare-only', 'Unsupported: preview surfaces belong to a future context/query command')
-        .option('--json', 'Unsupported: machine-readable context belongs to a future context/query command')
-        .option('--change <id>', 'Unsupported: change-scoped open belongs to future workspace change planning')
-        .option('--no-interactive', 'Disable prompts')
-        .action(async (name, options) => {
-        await workspaceCommand.open(name, options);
-    });
-    // Intentionally no public `workspace create` command in this slice.
+    registerWorkspaceCommandWith(program, new WorkspaceCommand());
 }
 //# sourceMappingURL=workspace.js.map

package/dist/core/artifact-graph/index.d.ts

@@ -4,5 +4,6 @@ export { ArtifactGraph } from './graph.js';
 export { detectCompleted } from './state.js';
 export { artifactOutputExists, isGlobPattern, resolveArtifactOutputs } from './outputs.js';
 export { resolveSchema, listSchemas, listSchemasWithInfo, getSchemaDir, getPackageSchemasDir, getUserSchemasDir, SchemaLoadError, type SchemaInfo, } from './resolver.js';
-export { loadTemplate, loadChangeContext, generateInstructions, formatChangeStatus, TemplateLoadError, type ChangeContext, type LoadChangeContextOptions, type ArtifactInstructions, type DependencyInfo, type ArtifactStatus, type ChangeStatus, type ArtifactPathSummary, type PlanningHomeSummary, type AffectedAreasSummary, type ActionContext, } from './instruction-loader.js';
+export { loadTemplate, loadChangeContext, generateInstructions, formatChangeStatus, TemplateLoadError, type ChangeContext, type LoadChangeContextOptions, type ArtifactInstructions, type DependencyInfo, type ArtifactStatus, type ChangeStatus, type ArtifactPathSummary, } from './instruction-loader.js';
+export type { PlanningHomeSummary, AffectedAreasSummary, ActionContext, } from '../change-status-policy.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/artifact-graph/instruction-loader.d.ts

@@ -1,5 +1,7 @@
 import { ArtifactGraph } from './graph.js';
+import { type ActionContext, type AffectedAreasSummary, type PlanningHomeSummary } from '../change-status-policy.js';
 import type { PlanningHome } from '../planning-home.js';
+import type { ChangeMetadata, InitiativeLink } from '../change-metadata/index.js';
 import type { CompletedSet } from './types.js';
 /**
  * Error thrown when loading a template fails.
@@ -26,6 +28,10 @@ export interface ChangeContext {
     projectRoot: string;
     /** Resolved planning home for this change */
     planningHome?: PlanningHome;
+    /** Parsed change metadata, when present */
+    metadata?: ChangeMetadata;
+    /** Stored initiative link, when this change is linked to shared context */
+    initiative?: InitiativeLink;
 }
 export interface LoadChangeContextOptions {
     changeDir?: string;
@@ -45,6 +51,8 @@ export interface ArtifactInstructions {
     changeDir: string;
     /** Resolved planning home for this change */
     planningHome?: PlanningHomeSummary;
+    /** Stored initiative link, when this change is linked to shared context */
+    initiative?: InitiativeLink;
     /** Output path pattern (e.g., "proposal.md") */
     outputPath: string;
     /** Absolute output path or glob pattern resolved under the change directory */
@@ -102,6 +110,8 @@ export interface ChangeStatus {
     schemaName: string;
     /** Resolved planning home for this change */
     planningHome?: PlanningHomeSummary;
+    /** Stored initiative link, when this change is linked to shared context */
+    initiative?: InitiativeLink;
     /** Full path to the change root */
     changeRoot: string;
     /** Absolute artifact path details keyed by artifact ID */
@@ -124,29 +134,6 @@ export interface ArtifactPathSummary {
     resolvedOutputPath: string;
     existingOutputPaths: string[];
 }
-export interface PlanningHomeSummary {
-    kind: 'repo' | 'workspace';
-    root: string;
-    changesDir: string;
-    defaultSchema: string;
-    workspaceName?: string;
-}
-export interface AffectedAreasSummary {
-    known: string[];
-    unresolved: boolean;
-    invalid: string[];
-}
-export interface ActionContext {
-    mode: 'repo-local' | 'workspace-planning';
-    sourceOfTruth: 'repo' | 'workspace';
-    planningArtifacts: string[];
-    linkedContext: Array<{
-        name: string;
-    }>;
-    allowedEditRoots: string[];
-    requiresAffectedAreaSelection: boolean;
-    constraints: string[];
-}
 /**
  * Loads a template from a schema's templates directory.
  *