gmc-openspec 1.0.0

package/dist/core/jira/mcp-config.js

@@ -0,0 +1,259 @@
+import { existsSync, readFileSync } from 'fs';
+import { promises as fs } from 'fs';
+import path from 'path';
+const ATLASSIAN_MCP_HOST = 'mcp.atlassian.com';
+const PROJECT_MCP_ADAPTERS = {
+    'github-copilot': {
+        toolId: 'github-copilot',
+        pathSegments: ['.vscode', 'mcp.json'],
+        containerKey: 'servers',
+        canonicalServerName: 'atlassian-mcp-server',
+        collisionServerName: 'atlassian-mcp-server-openspec',
+        includeInputs: true,
+    },
+    cursor: {
+        toolId: 'cursor',
+        pathSegments: ['.cursor', 'mcp.json'],
+        containerKey: 'mcpServers',
+        canonicalServerName: 'Atlassian-MCP-Server',
+        collisionServerName: 'Atlassian-MCP-Server-OpenSpec',
+    },
+    claude: {
+        toolId: 'claude',
+        pathSegments: ['.mcp.json'],
+        containerKey: 'mcpServers',
+        canonicalServerName: 'Atlassian-MCP-Server',
+        collisionServerName: 'Atlassian-MCP-Server-OpenSpec',
+    },
+};
+export async function ensureJiraMcpConfigs(projectRoot, toolIds, endpoint) {
+    const results = [];
+    for (const toolId of toolIds) {
+        results.push(await ensureJiraMcpConfig(projectRoot, toolId, endpoint));
+    }
+    return results;
+}
+export async function ensureJiraMcpConfig(projectRoot, toolId, endpoint) {
+    const computed = computeJiraMcpConfig(projectRoot, toolId, endpoint, 'ensure');
+    if (computed.nextContent && computed.targetPath) {
+        await fs.mkdir(path.dirname(computed.targetPath), { recursive: true });
+        await fs.writeFile(computed.targetPath, computed.nextContent, 'utf8');
+    }
+    return computed.result;
+}
+export function inspectJiraMcpConfig(projectRoot, toolId, endpoint) {
+    return computeJiraMcpConfig(projectRoot, toolId, endpoint, 'inspect').result;
+}
+export function getManualJiraMcpSetupHint(toolId, endpoint) {
+    if (toolId === 'codex') {
+        return `Codex MCP auto-write is not supported for project-local setup yet. Run: codex mcp add Atlassian-MCP-Server --url ${endpoint}`;
+    }
+    return `Configure this AI client with an official Atlassian MCP server using endpoint ${endpoint}.`;
+}
+function computeJiraMcpConfig(projectRoot, toolId, endpoint, mode) {
+    const adapter = PROJECT_MCP_ADAPTERS[toolId];
+    if (!adapter) {
+        return {
+            result: {
+                toolId,
+                status: 'unsupported',
+                message: getManualJiraMcpSetupHint(toolId, endpoint),
+            },
+        };
+    }
+    const targetPath = path.join(projectRoot, ...adapter.pathSegments);
+    if (!existsSync(targetPath)) {
+        const serverName = adapter.canonicalServerName;
+        return {
+            targetPath,
+            nextContent: serializeJson(createMcpConfig(adapter, endpoint, serverName)),
+            result: {
+                toolId,
+                status: 'created',
+                path: targetPath,
+                serverName,
+                message: mode === 'ensure'
+                    ? `Created official Atlassian MCP config for ${toolId}.`
+                    : `Official Atlassian MCP config is missing for ${toolId}; setup would create it.`,
+            },
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(targetPath, 'utf8'));
+    }
+    catch (error) {
+        return {
+            targetPath,
+            result: {
+                toolId,
+                status: 'invalid-json',
+                path: targetPath,
+                message: `Could not parse ${toDisplayPath(projectRoot, targetPath)}; fix the JSON before OpenSpec can add Atlassian MCP config. ${error instanceof Error ? error.message : String(error)}`,
+            },
+        };
+    }
+    if (!isRecord(parsed)) {
+        return {
+            targetPath,
+            result: {
+                toolId,
+                status: 'invalid-json',
+                path: targetPath,
+                message: `${toDisplayPath(projectRoot, targetPath)} must contain a JSON object before OpenSpec can add Atlassian MCP config.`,
+            },
+        };
+    }
+    const root = cloneRecord(parsed);
+    const existingContainer = root[adapter.containerKey];
+    if (existingContainer !== undefined && !isRecord(existingContainer)) {
+        return {
+            targetPath,
+            result: {
+                toolId,
+                status: 'invalid-json',
+                path: targetPath,
+                message: `${toDisplayPath(projectRoot, targetPath)} has a non-object ${adapter.containerKey} field; fix it before OpenSpec can add Atlassian MCP config.`,
+            },
+        };
+    }
+    const container = existingContainer ? cloneRecord(existingContainer) : {};
+    root[adapter.containerKey] = container;
+    const officialServerName = findOfficialAtlassianServerName(container);
+    if (officialServerName) {
+        const normalization = normalizeOfficialAtlassianServer(container[officialServerName], endpoint);
+        if (normalization.changed) {
+            container[officialServerName] = normalization.value;
+            return {
+                targetPath,
+                nextContent: serializeJson(root),
+                result: {
+                    toolId,
+                    status: 'updated',
+                    path: targetPath,
+                    serverName: officialServerName,
+                    message: mode === 'ensure'
+                        ? `Updated official Atlassian MCP endpoint for ${toolId}.`
+                        : `Official Atlassian MCP endpoint for ${toolId} needs refresh.`,
+                },
+            };
+        }
+        return {
+            targetPath,
+            result: {
+                toolId,
+                status: 'already-present',
+                path: targetPath,
+                serverName: officialServerName,
+                message: `Official Atlassian MCP config already exists for ${toolId}.`,
+            },
+        };
+    }
+    const serverName = chooseServerName(container, adapter);
+    container[serverName] = createAtlassianServerConfig(endpoint);
+    if (adapter.includeInputs && root.inputs === undefined) {
+        root.inputs = [];
+    }
+    return {
+        targetPath,
+        nextContent: serializeJson(root),
+        result: {
+            toolId,
+            status: 'updated',
+            path: targetPath,
+            serverName,
+            message: mode === 'ensure'
+                ? `Added official Atlassian MCP config for ${toolId}.`
+                : `Official Atlassian MCP config is missing for ${toolId}; setup would add it.`,
+        },
+    };
+}
+function createMcpConfig(adapter, endpoint, serverName) {
+    const config = {
+        [adapter.containerKey]: {
+            [serverName]: createAtlassianServerConfig(endpoint),
+        },
+    };
+    if (adapter.includeInputs) {
+        config.inputs = [];
+    }
+    return config;
+}
+function createAtlassianServerConfig(endpoint) {
+    return {
+        url: endpoint,
+        type: 'http',
+    };
+}
+function findOfficialAtlassianServerName(container) {
+    return Object.entries(container).find(([, server]) => containsAtlassianMcpHost(server))?.[0];
+}
+function chooseServerName(container, adapter) {
+    if (!(adapter.canonicalServerName in container)) {
+        return adapter.canonicalServerName;
+    }
+    if (!(adapter.collisionServerName in container)) {
+        return adapter.collisionServerName;
+    }
+    let suffix = 2;
+    while (`${adapter.collisionServerName}-${suffix}` in container) {
+        suffix++;
+    }
+    return `${adapter.collisionServerName}-${suffix}`;
+}
+function normalizeOfficialAtlassianServer(server, endpoint) {
+    if (!isRecord(server)) {
+        return { value: server, changed: false };
+    }
+    const next = cloneRecord(server);
+    let changed = false;
+    if (typeof next.url === 'string' && next.url.includes(ATLASSIAN_MCP_HOST)) {
+        if (next.url !== endpoint) {
+            next.url = endpoint;
+            changed = true;
+        }
+        if (next.type !== 'http') {
+            next.type = 'http';
+            changed = true;
+        }
+    }
+    if (Array.isArray(next.args)) {
+        const normalizedArgs = next.args.map((arg) => {
+            if (typeof arg !== 'string' || !arg.includes(ATLASSIAN_MCP_HOST)) {
+                return arg;
+            }
+            if (arg === endpoint) {
+                return arg;
+            }
+            changed = true;
+            return endpoint;
+        });
+        next.args = normalizedArgs;
+    }
+    return { value: next, changed };
+}
+function containsAtlassianMcpHost(value) {
+    if (typeof value === 'string') {
+        return value.includes(ATLASSIAN_MCP_HOST);
+    }
+    if (Array.isArray(value)) {
+        return value.some((item) => containsAtlassianMcpHost(item));
+    }
+    if (isRecord(value)) {
+        return Object.values(value).some((child) => containsAtlassianMcpHost(child));
+    }
+    return false;
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function cloneRecord(value) {
+    return { ...value };
+}
+function serializeJson(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+function toDisplayPath(projectRoot, targetPath) {
+    return path.relative(projectRoot, targetPath).split(path.sep).join('/');
+}
+//# sourceMappingURL=mcp-config.js.map

package/dist/core/jira/paths.d.ts

@@ -0,0 +1,12 @@
+export declare function normalizeJiraId(jiraId: string): string;
+export declare function validateJiraId(jiraId: string): {
+    valid: boolean;
+    error?: string;
+};
+export declare function slugify(input: string): string;
+export declare function getJiraConfigPath(projectRoot: string): string;
+export declare function getJiraRoot(projectRoot: string): string;
+export declare function getJiraIssueDir(projectRoot: string, jiraId: string, slug?: string): string;
+export declare function getJiraIssueFile(projectRoot: string, jiraId: string, fileName: string): string;
+export declare function toDisplayPath(projectRoot: string, targetPath: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/core/jira/paths.js

@@ -0,0 +1,66 @@
+import path from 'path';
+import { existsSync, readdirSync, statSync } from 'fs';
+import { OPENSPEC_DIR_NAME } from '../config.js';
+import { JIRA_CONFIG_FILE, JIRA_DIR_NAME } from './constants.js';
+const ISSUE_ID_PATTERN = /^[A-Z][A-Z0-9]+-\d+$/;
+export function normalizeJiraId(jiraId) {
+    return jiraId.trim().toUpperCase();
+}
+export function validateJiraId(jiraId) {
+    const normalized = normalizeJiraId(jiraId);
+    if (!normalized) {
+        return { valid: false, error: 'Jira issue id cannot be empty' };
+    }
+    if (!ISSUE_ID_PATTERN.test(normalized)) {
+        return { valid: false, error: 'Jira issue id must look like ABC-123' };
+    }
+    return { valid: true };
+}
+export function slugify(input) {
+    const slug = input
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .replace(/-{2,}/g, '-');
+    return slug || 'jira-intake';
+}
+export function getJiraConfigPath(projectRoot) {
+    return path.join(projectRoot, OPENSPEC_DIR_NAME, JIRA_CONFIG_FILE);
+}
+export function getJiraRoot(projectRoot) {
+    return path.join(projectRoot, JIRA_DIR_NAME);
+}
+export function getJiraIssueDir(projectRoot, jiraId, slug) {
+    const normalized = normalizeJiraId(jiraId);
+    const root = getJiraRoot(projectRoot);
+    if (slug) {
+        return path.join(root, `${normalized}-${slugify(slug)}`);
+    }
+    if (existsSync(root)) {
+        const prefix = `${normalized}-`;
+        const matches = readdirSync(root)
+            .filter((entry) => entry === normalized || entry.startsWith(prefix))
+            .map((entry) => path.join(root, entry))
+            .filter((candidate) => {
+            try {
+                return statSync(candidate).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        })
+            .sort();
+        if (matches.length > 0) {
+            return matches[0];
+        }
+    }
+    return path.join(root, normalized);
+}
+export function getJiraIssueFile(projectRoot, jiraId, fileName) {
+    return path.join(getJiraIssueDir(projectRoot, jiraId), fileName);
+}
+export function toDisplayPath(projectRoot, targetPath) {
+    return path.relative(projectRoot, targetPath).split(path.sep).join('/');
+}
+//# sourceMappingURL=paths.js.map

package/dist/core/jira/setup.d.ts

@@ -0,0 +1,30 @@
+import type { Delivery } from '../global-config.js';
+import { type JiraConfig } from './config.js';
+import { type JiraMcpConfigResult } from './mcp-config.js';
+export interface JiraSetupOptions {
+    tools?: string;
+    provider?: string;
+    endpoint?: string;
+    force?: boolean;
+    delivery?: Delivery;
+    generatedByVersion: string;
+}
+export interface JiraSetupResult {
+    configPath: string;
+    config: JiraConfig;
+    tools: string[];
+    skillsWritten: number;
+    commandsWritten: number;
+    commandsSkipped: string[];
+    mcpConfigResults: JiraMcpConfigResult[];
+    snippets: Record<string, string>;
+}
+export declare function resolveJiraToolIds(projectRoot: string, toolsArg?: string): string[];
+export declare function setupJiraIntegration(projectRoot: string, options: JiraSetupOptions): Promise<JiraSetupResult>;
+export declare function installJiraArtifacts(projectRoot: string, toolIds: string[], delivery: Delivery, generatedByVersion: string): Promise<{
+    skillsWritten: number;
+    commandsWritten: number;
+    commandsSkipped: string[];
+}>;
+export declare function getMcpSnippet(endpoint: string): string;
+//# sourceMappingURL=setup.d.ts.map

package/dist/core/jira/setup.js

@@ -0,0 +1,99 @@
+import path from 'path';
+import { AI_TOOLS } from '../config.js';
+import { getAvailableTools } from '../available-tools.js';
+import { generateCommands, CommandAdapterRegistry } from '../command-generation/index.js';
+import { generateSkillContent } from '../shared/skill-generation.js';
+import { FileSystemUtils } from '../../utils/file-system.js';
+import { transformToHyphenCommands } from '../../utils/command-references.js';
+import { createDefaultJiraConfig, writeJiraConfig } from './config.js';
+import { JIRA_DEFAULT_ENDPOINT } from './constants.js';
+import { ensureJiraMcpConfigs } from './mcp-config.js';
+import { getJiraCommandContents, getJiraSkillTemplates } from './templates.js';
+export function resolveJiraToolIds(projectRoot, toolsArg) {
+    const validToolIds = AI_TOOLS.filter((tool) => tool.skillsDir).map((tool) => tool.value);
+    const validSet = new Set(validToolIds);
+    const requested = toolsArg?.trim() || 'detected';
+    if (requested === 'none')
+        return [];
+    if (requested === 'all')
+        return validToolIds;
+    if (requested === 'detected') {
+        return getAvailableTools(projectRoot).map((tool) => tool.value);
+    }
+    const ids = requested.split(',').map((tool) => tool.trim()).filter(Boolean);
+    for (const id of ids) {
+        if (!validSet.has(id)) {
+            throw new Error(`Unknown Jira setup tool "${id}". Use all, none, detected, or one of: ${validToolIds.join(', ')}`);
+        }
+    }
+    return [...new Set(ids)];
+}
+export async function setupJiraIntegration(projectRoot, options) {
+    if (options.provider && options.provider !== 'atlassian-rovo') {
+        throw new Error('V1 Jira intake supports only provider "atlassian-rovo"');
+    }
+    const tools = resolveJiraToolIds(projectRoot, options.tools);
+    const config = createDefaultJiraConfig(tools);
+    config.provider = 'atlassian-rovo';
+    config.endpoint = options.endpoint ?? JIRA_DEFAULT_ENDPOINT;
+    config.tools = tools;
+    const configPath = await writeJiraConfig(projectRoot, config, { force: options.force });
+    const installResult = await installJiraArtifacts(projectRoot, tools, options.delivery ?? 'both', options.generatedByVersion);
+    const mcpConfigResults = await ensureJiraMcpConfigs(projectRoot, tools, config.endpoint);
+    return {
+        configPath,
+        config,
+        tools,
+        ...installResult,
+        mcpConfigResults,
+        snippets: Object.fromEntries(tools.map((toolId) => [toolId, getMcpSnippet(config.endpoint)])),
+    };
+}
+export async function installJiraArtifacts(projectRoot, toolIds, delivery, generatedByVersion) {
+    const shouldGenerateSkills = delivery !== 'commands';
+    const shouldGenerateCommands = delivery !== 'skills';
+    const skillTemplates = getJiraSkillTemplates();
+    const commandContents = getJiraCommandContents();
+    const commandsSkipped = [];
+    let skillsWritten = 0;
+    let commandsWritten = 0;
+    for (const toolId of toolIds) {
+        const tool = AI_TOOLS.find((candidate) => candidate.value === toolId);
+        if (!tool?.skillsDir)
+            continue;
+        if (shouldGenerateSkills) {
+            const skillsDir = path.join(projectRoot, tool.skillsDir, 'skills');
+            for (const { template, dirName } of skillTemplates) {
+                const skillFile = path.join(skillsDir, dirName, 'SKILL.md');
+                const transformer = tool.value === 'opencode' || tool.value === 'pi' ? transformToHyphenCommands : undefined;
+                await FileSystemUtils.writeFile(skillFile, generateSkillContent(template, generatedByVersion, transformer));
+                skillsWritten++;
+            }
+        }
+        if (shouldGenerateCommands) {
+            const adapter = CommandAdapterRegistry.get(tool.value);
+            if (!adapter) {
+                commandsSkipped.push(tool.value);
+                continue;
+            }
+            const generatedCommands = generateCommands(commandContents, adapter);
+            for (const command of generatedCommands) {
+                const commandFile = path.isAbsolute(command.path) ? command.path : path.join(projectRoot, command.path);
+                await FileSystemUtils.writeFile(commandFile, command.fileContent);
+                commandsWritten++;
+            }
+        }
+    }
+    return { skillsWritten, commandsWritten, commandsSkipped };
+}
+export function getMcpSnippet(endpoint) {
+    return JSON.stringify({
+        mcpServers: {
+            atlassian: {
+                command: 'npx',
+                args: ['-y', 'mcp-remote', endpoint],
+            },
+        },
+    }, null, 2);
+}
+//# sourceMappingURL=setup.js.map

package/dist/core/jira/templates.d.ts

@@ -0,0 +1,12 @@
+import type { CommandContent } from '../command-generation/index.js';
+import type { SkillTemplate } from '../templates/types.js';
+import { type JiraWorkflowId } from './constants.js';
+export interface JiraSkillTemplateEntry {
+    workflowId: JiraWorkflowId;
+    dirName: string;
+    template: SkillTemplate;
+}
+export declare function getJiraSkillTemplates(): JiraSkillTemplateEntry[];
+export declare function getJiraCommandContents(): CommandContent[];
+export declare function isJiraWorkflowId(value: string): value is JiraWorkflowId;
+//# sourceMappingURL=templates.d.ts.map

package/dist/core/jira/templates.js

@@ -0,0 +1,204 @@
+import { JIRA_WORKFLOW_IDS, JIRA_WORKFLOW_TO_SKILL_DIR } from './constants.js';
+const SHARED_GUARDRAILS = `
+## Boundary Guardrails
+
+- Treat Jira as the business input source, not the final engineering specification.
+- Never create or modify \`openspec/changes/*\` directly from raw Jira description or comments.
+- Never modify \`source.md\`; it is a read-only Jira snapshot protected by \`sourceHashSha256\` in \`intake.yaml\`.
+- Blocking questions must be answered before requirements can be marked reviewed.
+- Assumptions must be explicit in \`assumptions.md\` and approved before story split or OpenSpec proposal.
+- Keep \`mapping.yaml\` current so Jira AC maps to requirements, stories, and OpenSpec changes.
+- Use official Atlassian MCP Jira tools by their concrete names; do not enumerate every MCP tool to discover Jira capabilities.
+- If the named Atlassian MCP tools are unavailable, stop and report MCP setup or OAuth authorization as the blocker.
+`;
+const WORKFLOWS = [
+    {
+        id: 'jira-import',
+        name: 'OPSX: Jira Import',
+        description: 'Import a Jira epic or feature into a local auditable intake folder before OpenSpec planning.',
+        body: `Import a Jira ticket into OpenSpec intake.
+
+**Input**: Jira issue id such as \`ABC-123\`.
+
+${SHARED_GUARDRAILS}
+
+## Steps
+
+1. Use the official Atlassian MCP Jira tool \`getJiraIssue\` to read the issue by id.
+   - Read summary, description, acceptance criteria, comments, linked issues, labels, components, and attachments metadata where available.
+   - Use \`getJiraIssueRemoteIssueLinks\` and \`searchJiraIssuesUsingJql\` only when linked issues or related ticket lookup is needed.
+   - Do not write to Jira.
+2. Create \`jira/<JIRA-ID>-<slug>/\` using a short slug from the Jira summary.
+3. Write \`source.md\` as an auditable snapshot with field names and source sections.
+4. Compute SHA-256 of \`source.md\` and write \`intake.yaml\`:
+   \`schemaVersion: 1\`, \`jira\`, \`status: imported\`, \`sourceHashSha256\`.
+5. Write \`requirement-draft.md\` as a concise product requirement draft.
+6. Write initial \`questions.md\`, \`assumptions.md\`, and \`mapping.yaml\` placeholders.
+7. Run \`openspec jira validate <JIRA-ID> --stage source\` and report the result.
+
+## Output
+
+Summarize the intake folder, the source hash, and the next command: \`/opsx:jira-refine <JIRA-ID>\`.`,
+    },
+    {
+        id: 'jira-refine',
+        name: 'OPSX: Jira Refine',
+        description: 'Clarify imported Jira requirements until blocking ambiguity is resolved.',
+        body: `Refine an imported Jira ticket into a clear reviewed requirement.
+
+**Input**: Jira issue id such as \`ABC-123\`.
+
+${SHARED_GUARDRAILS}
+
+## Steps
+
+1. Run \`openspec jira status <JIRA-ID> --json\` and read the intake folder.
+2. Read \`source.md\`, \`requirement-draft.md\`, \`questions.md\`, \`assumptions.md\`, and \`mapping.yaml\`.
+3. Identify ambiguity as either:
+   - **Blocking**: affects scope, AC, permissions, data contract, external behavior, or story boundaries.
+   - **Non-Blocking**: can be captured as an explicit assumption.
+4. Ask the user all blocking questions before proceeding. Update \`questions.md\` with statuses.
+5. Record non-blocking assumptions in \`assumptions.md\`; do not hide assumptions in requirement prose.
+6. When blocking questions are resolved, write \`requirement.md\` and set \`intake.yaml\` status to \`ready-for-review\`.
+7. Run \`openspec jira validate <JIRA-ID> --stage requirement\`.
+
+## Output
+
+Summarize resolved questions, remaining assumptions, and ask the user to explicitly review via \`/opsx:jira-review <JIRA-ID>\`.`,
+    },
+    {
+        id: 'jira-review',
+        name: 'OPSX: Jira Review',
+        description: 'Review and approve the refined Jira requirement before story splitting.',
+        body: `Review a refined Jira requirement.
+
+**Input**: Jira issue id such as \`ABC-123\`.
+
+${SHARED_GUARDRAILS}
+
+## Steps
+
+1. Read \`requirement.md\`, \`questions.md\`, and \`assumptions.md\`.
+2. Run \`openspec jira validate <JIRA-ID> --stage requirement --json\`.
+3. If validation fails, explain the blockers and return to \`/opsx:jira-refine\`.
+4. Ask the user to approve or request edits to the requirement and assumptions.
+5. Only after explicit approval, set \`intake.yaml\` status to \`reviewed\`.
+
+## Output
+
+State whether the requirement is reviewed and ready for \`/opsx:jira-split <JIRA-ID>\`.`,
+    },
+    {
+        id: 'jira-split',
+        name: 'OPSX: Jira Split',
+        description: 'Split a reviewed Jira requirement into implementation-ready stories.',
+        body: `Split a reviewed Jira requirement into stories.
+
+**Input**: Jira issue id such as \`ABC-123\`.
+
+${SHARED_GUARDRAILS}
+
+## Story Criteria
+
+Each story must have independent review value, clear AC, scope, non-goals, dependencies, and a traceable requirement source. Avoid one giant change and avoid tiny implementation-only fragments.
+
+## Steps
+
+1. Run \`openspec jira validate <JIRA-ID> --stage requirement --json\`.
+2. Read \`requirement.md\`, \`mapping.yaml\`, and existing OpenSpec specs if capability choices are unclear.
+3. Write \`stories.md\` with story ids, titles, scope, non-goals, AC, dependencies, risks, and suggested OpenSpec change names.
+4. Update \`mapping.yaml\` so every Jira AC maps to at least one story.
+5. Set \`intake.yaml\` status to \`split\` and ask the user to review the story split.
+6. After explicit user approval, set status to \`stories-reviewed\` and run \`openspec jira validate <JIRA-ID> --stage stories\`.
+
+## Output
+
+Summarize story count, deferred items, and next command: \`/opsx:jira-propose <JIRA-ID>\`.`,
+    },
+    {
+        id: 'jira-propose',
+        name: 'OPSX: Jira Propose',
+        description: 'Create one OpenSpec change per reviewed Jira story.',
+        body: `Create OpenSpec changes from reviewed Jira stories.
+
+**Input**: Jira issue id such as \`ABC-123\`.
+
+${SHARED_GUARDRAILS}
+
+## Steps
+
+1. Run \`openspec jira validate <JIRA-ID> --stage stories --json\`. Stop if it fails.
+2. Read \`stories.md\`, \`mapping.yaml\`, and \`requirement.md\`.
+3. For each non-deferred reviewed story, create exactly one OpenSpec change:
+   \`openspec new change <jira-id>-<story-slug>\`.
+4. Generate artifacts through the existing OpenSpec flow:
+   - Run \`openspec status --change <change> --json\`.
+   - For each ready artifact, run \`openspec instructions <artifact> --change <change> --json\`.
+   - Create \`proposal.md\`, delta specs, \`design.md\`, and \`tasks.md\` from the reviewed story and requirement, not raw Jira text.
+5. Update \`mapping.yaml\` so every story records its OpenSpec change and spec files.
+6. Set \`intake.yaml\` status to \`proposed\` and run \`openspec jira validate <JIRA-ID> --stage propose\`.
+
+## Output
+
+List created changes and remind the user to review before \`/opsx:apply\`.`,
+    },
+    {
+        id: 'jira-sync',
+        name: 'OPSX: Jira Sync',
+        description: 'Synchronize reviewed OpenSpec progress back to Jira with explicit confirmation.',
+        body: `Sync OpenSpec intake progress back to Jira.
+
+**Input**: Jira issue id such as \`ABC-123\`.
+
+${SHARED_GUARDRAILS}
+
+## Writeback Rules
+
+- This is the only Jira intake workflow allowed to write to Jira.
+- Before any Jira comment, child issue creation, link update, or status change, show a concrete diff of the write.
+- Ask for explicit confirmation before each batch of writes.
+- If \`openspec/jira.yaml\` has \`writeback.enabled: false\`, ask the user to confirm this one-time sync before writing.
+- Use only the official Atlassian MCP Jira write tools needed for the confirmed diff: \`addCommentToJiraIssue\`, \`editJiraIssue\`, \`getTransitionsForJiraIssue\`, \`transitionJiraIssue\`, and \`createJiraIssue\`.
+
+## Steps
+
+1. Run \`openspec jira validate <JIRA-ID> --stage propose --json\` when syncing proposed OpenSpec changes.
+2. Read \`mapping.yaml\`, \`stories.md\`, and current OpenSpec change status.
+3. Prepare a writeback plan: comments, links, child issues, or status moves.
+4. Show the diff and wait for explicit user approval.
+5. Use the named Atlassian MCP write tools only after approval.
+6. Update \`intake.yaml\` status to \`synced\` only after successful writeback.
+
+## Output
+
+Summarize exactly what was written to Jira and what remains local-only.`,
+    },
+];
+export function getJiraSkillTemplates() {
+    return WORKFLOWS.map((workflow) => ({
+        workflowId: workflow.id,
+        dirName: JIRA_WORKFLOW_TO_SKILL_DIR[workflow.id],
+        template: {
+            name: `openspec-${workflow.id}`,
+            description: workflow.description,
+            instructions: workflow.body,
+            license: 'MIT',
+            compatibility: 'Requires openspec CLI and a configured Jira MCP server.',
+            metadata: { author: 'openspec', version: '1.0' },
+        },
+    }));
+}
+export function getJiraCommandContents() {
+    return WORKFLOWS.map((workflow) => ({
+        id: workflow.id,
+        name: workflow.name,
+        description: workflow.description,
+        category: 'Jira Intake',
+        tags: ['jira', 'intake', 'openspec'],
+        body: workflow.body,
+    }));
+}
+export function isJiraWorkflowId(value) {
+    return JIRA_WORKFLOW_IDS.includes(value);
+}
+//# sourceMappingURL=templates.js.map