@codewalla_india/openspec 1.3.0 → 1.3.2

package/dist/core/completions/templates/zsh-templates.js

@@ -2,44 +2,44 @@
  * Static template strings for Zsh completion scripts.
  * These are Zsh-specific helper functions that never change.
  */
-export const ZSH_DYNAMIC_HELPERS = `# Dynamic completion helpers
-
-# Use openspec __complete to get available changes
-_openspec_complete_changes() {
-  local -a changes
-  while IFS=$'\\t' read -r id desc; do
-    changes+=("$id:$desc")
-  done < <(openspec __complete changes 2>/dev/null)
-  _describe "change" changes
-}
-
-# Use openspec __complete to get available specs
-_openspec_complete_specs() {
-  local -a specs
-  while IFS=$'\\t' read -r id desc; do
-    specs+=("$id:$desc")
-  done < <(openspec __complete specs 2>/dev/null)
-  _describe "spec" specs
-}
-
-# Get both changes and specs
-_openspec_complete_items() {
-  local -a items
-  while IFS=$'\\t' read -r id desc; do
-    items+=("$id:$desc")
-  done < <(openspec __complete changes 2>/dev/null)
-  while IFS=$'\\t' read -r id desc; do
-    items+=("$id:$desc")
-  done < <(openspec __complete specs 2>/dev/null)
-  _describe "item" items
-}
-
-# Use openspec __complete to get available schemas
-_openspec_complete_schemas() {
-  local -a schemas
-  while IFS=$'\\t' read -r id desc; do
-    schemas+=("$id:$desc")
-  done < <(openspec __complete schemas 2>/dev/null)
-  _describe "schema" schemas
+export const ZSH_DYNAMIC_HELPERS = `# Dynamic completion helpers
+
+# Use openspec __complete to get available changes
+_openspec_complete_changes() {
+  local -a changes
+  while IFS=$'\\t' read -r id desc; do
+    changes+=("$id:$desc")
+  done < <(openspec __complete changes 2>/dev/null)
+  _describe "change" changes
+}
+
+# Use openspec __complete to get available specs
+_openspec_complete_specs() {
+  local -a specs
+  while IFS=$'\\t' read -r id desc; do
+    specs+=("$id:$desc")
+  done < <(openspec __complete specs 2>/dev/null)
+  _describe "spec" specs
+}
+
+# Get both changes and specs
+_openspec_complete_items() {
+  local -a items
+  while IFS=$'\\t' read -r id desc; do
+    items+=("$id:$desc")
+  done < <(openspec __complete changes 2>/dev/null)
+  while IFS=$'\\t' read -r id desc; do
+    items+=("$id:$desc")
+  done < <(openspec __complete specs 2>/dev/null)
+  _describe "item" items
+}
+
+# Use openspec __complete to get available schemas
+_openspec_complete_schemas() {
+  local -a schemas
+  while IFS=$'\\t' read -r id desc; do
+    schemas+=("$id:$desc")
+  done < <(openspec __complete schemas 2>/dev/null)
+  _describe "schema" schemas
 }`;
 //# sourceMappingURL=zsh-templates.js.map

package/dist/core/config-prompts.d.ts

@@ -2,7 +2,7 @@ import type { ProjectConfig } from './project-config.js';
 /**
  * Serialize config to YAML string with helpful comments.
  *
- * @param config - Partial config object (schema required, context/rules optional)
+ * @param config - Partial config object (schema required, other fields optional)
  * @returns YAML string ready to write to file
  */
 export declare function serializeConfig(config: Partial<ProjectConfig>): string;

package/dist/core/config-prompts.js

@@ -1,7 +1,7 @@
 /**
  * Serialize config to YAML string with helpful comments.
  *
- * @param config - Partial config object (schema required, context/rules optional)
+ * @param config - Partial config object (schema required, other fields optional)
  * @returns YAML string ready to write to file
  */
 export function serializeConfig(config) {
@@ -29,6 +29,19 @@ export function serializeConfig(config) {
     lines.push('#       - Always include a "Non-goals" section');
     lines.push('#     tasks:');
     lines.push('#       - Break tasks into chunks of max 2 hours');
+    lines.push('');
+    // Operation guidance section with comments
+    lines.push('# Per-operation guidance (optional)');
+    lines.push('# Add advisory guidance for how apply and archive work should be conducted.');
+    lines.push('# This is separate from artifact rules above.');
+    lines.push('# Example:');
+    lines.push('#   operations:');
+    lines.push('#     apply:');
+    lines.push('#       guidance:');
+    lines.push('#         - Keep test summaries concise');
+    lines.push('#     archive:');
+    lines.push('#       guidance:');
+    lines.push('#         - Summarize the archive outcome before finishing');
     return lines.join('\n') + '\n';
 }
 //# sourceMappingURL=config-prompts.js.map

package/dist/core/config-schema.d.ts

@@ -11,16 +11,25 @@ export declare const GlobalConfigSchema: z.ZodObject<{
     }>>>;
     delivery: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         commands: "commands";
-        skills: "skills";
         both: "both";
+        skills: "skills";
     }>>>;
     workflows: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    defaultStore: z.ZodOptional<z.ZodString>;
+    telemetry: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
 }, z.core.$loose>;
 export type GlobalConfigType = z.infer<typeof GlobalConfigSchema>;
 /**
  * Default configuration values.
  */
 export declare const DEFAULT_CONFIG: GlobalConfigType;
+/**
+ * True when a dot-notation key path contains a prototype-reaching segment.
+ * Callers that bypass key validation (e.g. --allow-unknown) still must not bypass this.
+ */
+export declare function hasUnsafeKeySegment(path: string): boolean;
 /**
  * Validate a config key path for CLI set operations.
  * Unknown top-level keys are rejected unless explicitly allowed by the caller.

package/dist/core/config-schema.js

@@ -20,6 +20,18 @@ export const GlobalConfigSchema = z
     workflows: z
         .array(z.string())
         .optional(),
+    defaultStore: z
+        .string()
+        .optional()
+        .describe('Store id used as fallback root when no explicit --store, local root, or project-level store: pointer resolves'),
+    // passthrough keeps runtime-managed fields (anonymousId, noticeSeen) valid
+    // under CLI validate when users only set telemetry.enabled.
+    telemetry: z
+        .object({
+        enabled: z.boolean().optional(),
+    })
+        .passthrough()
+        .optional(),
 })
     .passthrough();
 /**
@@ -30,7 +42,29 @@ export const DEFAULT_CONFIG = {
     profile: 'core',
     delivery: 'both',
 };
-const KNOWN_TOP_LEVEL_KEYS = new Set([...Object.keys(DEFAULT_CONFIG), 'workflows']);
+const KNOWN_TOP_LEVEL_KEYS = new Set([
+    ...Object.keys(DEFAULT_CONFIG),
+    'workflows',
+    'defaultStore',
+    'telemetry',
+]);
+/** Nested keys users may set under `telemetry` via the CLI. */
+const TELEMETRY_SETTABLE_KEYS = new Set(['enabled']);
+/**
+ * Key segments that would reach the prototype chain instead of the config object.
+ * Never valid as configuration keys, so rejecting them costs nothing.
+ */
+const UNSAFE_KEY_SEGMENTS = new Set(['__proto__', 'constructor', 'prototype']);
+function hasUnsafeSegment(keys) {
+    return keys.some((key) => UNSAFE_KEY_SEGMENTS.has(key));
+}
+/**
+ * True when a dot-notation key path contains a prototype-reaching segment.
+ * Callers that bypass key validation (e.g. --allow-unknown) still must not bypass this.
+ */
+export function hasUnsafeKeySegment(path) {
+    return hasUnsafeSegment(path.split('.'));
+}
 /**
  * Validate a config key path for CLI set operations.
  * Unknown top-level keys are rejected unless explicitly allowed by the caller.
@@ -40,6 +74,10 @@ export function validateConfigKeyPath(path) {
     if (rawKeys.length === 0 || rawKeys.some((key) => key.trim() === '')) {
         return { valid: false, reason: 'Key path must not be empty' };
     }
+    const unsafeKey = rawKeys.find((key) => UNSAFE_KEY_SEGMENTS.has(key));
+    if (unsafeKey) {
+        return { valid: false, reason: `Key segment "${unsafeKey}" is not allowed` };
+    }
     const rootKey = rawKeys[0];
     if (!KNOWN_TOP_LEVEL_KEYS.has(rootKey)) {
         return { valid: false, reason: `Unknown top-level key "${rootKey}"` };
@@ -50,6 +88,18 @@ export function validateConfigKeyPath(path) {
         }
         return { valid: true };
     }
+    if (rootKey === 'telemetry') {
+        if (rawKeys.length === 1) {
+            return { valid: false, reason: 'Set nested keys under telemetry (e.g. telemetry.enabled)' };
+        }
+        if (rawKeys.length !== 2 || !TELEMETRY_SETTABLE_KEYS.has(rawKeys[1])) {
+            return {
+                valid: false,
+                reason: `Unknown telemetry key "${rawKeys.slice(1).join('.')}" (allowed: enabled)`,
+            };
+        }
+        return { valid: true };
+    }
     if (rawKeys.length > 1) {
         return { valid: false, reason: `"${rootKey}" does not support nested keys` };
     }
@@ -64,6 +114,9 @@ export function validateConfigKeyPath(path) {
  */
 export function getNestedValue(obj, path) {
     const keys = path.split('.');
+    if (hasUnsafeSegment(keys)) {
+        return undefined;
+    }
     let current = obj;
     for (const key of keys) {
         if (current === null || current === undefined) {
@@ -86,6 +139,14 @@ export function getNestedValue(obj, path) {
  */
 export function setNestedValue(obj, path, value) {
     const keys = path.split('.');
+    // Compared literally rather than through a helper, so the guard is plain to a
+    // reader and to static analysis. Checked for the whole path before anything is
+    // written, so a rejected key never leaves half-created objects behind.
+    for (const key of keys) {
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+            return;
+        }
+    }
     let current = obj;
     for (let i = 0; i < keys.length - 1; i++) {
         const key = keys[i];
@@ -106,6 +167,11 @@ export function setNestedValue(obj, path, value) {
  */
 export function deleteNestedValue(obj, path) {
     const keys = path.split('.');
+    for (const key of keys) {
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+            return false;
+        }
+    }
     let current = obj;
     for (let i = 0; i < keys.length - 1; i++) {
         const key = keys[i];

package/dist/core/config.d.ts

@@ -1,4 +1,5 @@
 export declare const OPENSPEC_DIR_NAME = "openspec";
+export declare const OPENSPEC_SKILL_NAMES: readonly ["openspec-explore", "openspec-new-change", "openspec-continue-change", "openspec-apply-change", "openspec-update-change", "openspec-ff-change", "openspec-sync-specs", "openspec-archive-change", "openspec-bulk-archive-change", "openspec-verify-change", "openspec-onboard", "openspec-propose"];
 export declare const OPENSPEC_MARKERS: {
     start: string;
     end: string;
@@ -12,7 +13,21 @@ export interface AIToolOption {
     available: boolean;
     successLabel?: string;
     skillsDir?: string;
+    legacySkillsDirs?: string[];
+    globalSkillsDir?: string;
     detectionPaths?: string[];
+    setupNote?: string;
 }
 export declare const AI_TOOLS: AIToolOption[];
+/**
+ * Retired tool ids that still resolve, so a rebrand does not break scripted
+ * `--tools` invocations. Windsurf was rebranded to Devin Desktop on
+ * 2026-06-02 and its config directory moved from `.windsurf/` to `.devin/`;
+ * `--tools windsurf` therefore configures `devin`.
+ */
+export declare const TOOL_ID_ALIASES: Record<string, string>;
+/**
+ * Resolves a tool id through TOOL_ID_ALIASES, leaving current ids untouched.
+ */
+export declare function resolveToolIdAlias(toolId: string): string;
 //# sourceMappingURL=config.d.ts.map

package/dist/core/config.js

@@ -1,4 +1,18 @@
 export const OPENSPEC_DIR_NAME = 'openspec';
+export const OPENSPEC_SKILL_NAMES = [
+    'openspec-explore',
+    'openspec-new-change',
+    'openspec-continue-change',
+    'openspec-apply-change',
+    'openspec-update-change',
+    'openspec-ff-change',
+    'openspec-sync-specs',
+    'openspec-archive-change',
+    'openspec-bulk-archive-change',
+    'openspec-verify-change',
+    'openspec-onboard',
+    'openspec-propose',
+];
 export const OPENSPEC_MARKERS = {
     start: '<!-- OPENSPEC:START -->',
     end: '<!-- OPENSPEC:END -->'
@@ -10,7 +24,9 @@ export const AI_TOOLS = [
     { name: 'Bob Shell', value: 'bob', available: true, successLabel: 'Bob Shell', skillsDir: '.bob' },
     { name: 'Claude Code', value: 'claude', available: true, successLabel: 'Claude Code', skillsDir: '.claude' },
     { name: 'Cline', value: 'cline', available: true, successLabel: 'Cline', skillsDir: '.cline' },
-    { name: 'Codex', value: 'codex', available: true, successLabel: 'Codex', skillsDir: '.codex' },
+    { name: 'CodeArts', value: 'codeartsagent', available: true, successLabel: 'CodeArts', skillsDir: '.codeartsdoer' },
+    { name: 'Codex', value: 'codex', available: true, successLabel: 'Codex', skillsDir: '.agents', legacySkillsDirs: ['.codex'], detectionPaths: ['.agents/skills', '.codex/skills'] },
+    { name: 'Devin Desktop (formerly Windsurf)', value: 'devin', available: true, successLabel: 'Devin Desktop', skillsDir: '.devin', detectionPaths: ['.devin', '.windsurf'] },
     { name: 'ForgeCode', value: 'forgecode', available: true, successLabel: 'ForgeCode', skillsDir: '.forge' },
     { name: 'CodeBuddy Code (CLI)', value: 'codebuddy', available: true, successLabel: 'CodeBuddy Code', skillsDir: '.codebuddy' },
     { name: 'Continue', value: 'continue', available: true, successLabel: 'Continue (VS Code / JetBrains / Cli)', skillsDir: '.continue' },
@@ -20,20 +36,45 @@ export const AI_TOOLS = [
     { name: 'Factory Droid', value: 'factory', available: true, successLabel: 'Factory Droid', skillsDir: '.factory' },
     { name: 'Gemini CLI', value: 'gemini', available: true, successLabel: 'Gemini CLI', skillsDir: '.gemini' },
     { name: 'GitHub Copilot', value: 'github-copilot', available: true, successLabel: 'GitHub Copilot', skillsDir: '.github', detectionPaths: ['.github/copilot-instructions.md', '.github/instructions', '.github/workflows/copilot-setup-steps.yml', '.github/prompts', '.github/agents', '.github/skills', '.github/.mcp.json'] },
+    { name: 'Hermes Agent', value: 'hermes', available: true, successLabel: 'Hermes Agent', skillsDir: '.hermes', detectionPaths: ['.hermes', 'HERMES.md', '.hermes.md'], setupNote: "Hermes only loads skills from ~/.hermes/skills by default. Add this project's .hermes/skills directory to skills.external_dirs in ~/.hermes/config.yaml so Hermes picks up the generated OpenSpec skills." },
     { name: 'iFlow', value: 'iflow', available: true, successLabel: 'iFlow', skillsDir: '.iflow' },
     { name: 'Junie', value: 'junie', available: true, successLabel: 'Junie', skillsDir: '.junie' },
     { name: 'Kilo Code', value: 'kilocode', available: true, successLabel: 'Kilo Code', skillsDir: '.kilocode' },
-    { name: 'Kimi CLI', value: 'kimi', available: true, successLabel: 'Kimi CLI', skillsDir: '.kimi' },
+    { name: 'Kimi Code', value: 'kimi', available: true, successLabel: 'Kimi Code', skillsDir: '.kimi-code', detectionPaths: ['.kimi-code', '.kimi'] },
     { name: 'Kiro', value: 'kiro', available: true, successLabel: 'Kiro', skillsDir: '.kiro' },
     { name: 'Lingma', value: 'lingma', available: true, successLabel: 'Lingma', skillsDir: '.lingma' },
+    { name: 'MiniMax Code', value: 'minimax-code', available: true, successLabel: 'MiniMax Code', globalSkillsDir: '.minimax' },
     { name: 'Mistral Vibe', value: 'vibe', available: true, successLabel: 'Mistral Vibe', skillsDir: '.vibe' },
+    { name: 'Oh My Pi', value: 'oh-my-pi', available: true, successLabel: 'Oh My Pi', skillsDir: '.omp' },
     { name: 'OpenCode', value: 'opencode', available: true, successLabel: 'OpenCode', skillsDir: '.opencode' },
     { name: 'Pi', value: 'pi', available: true, successLabel: 'Pi', skillsDir: '.pi' },
     { name: 'Qoder', value: 'qoder', available: true, successLabel: 'Qoder', skillsDir: '.qoder' },
     { name: 'Qwen Code', value: 'qwen', available: true, successLabel: 'Qwen Code', skillsDir: '.qwen' },
-    { name: 'RooCode', value: 'roocode', available: true, successLabel: 'RooCode', skillsDir: '.roo' },
+    { name: 'Rovo Dev CLI', value: 'rovodev', available: true, successLabel: 'Rovo Dev CLI', skillsDir: '.rovodev', detectionPaths: ['.rovodev/skills', '.rovodev'] },
+    { name: 'Zoo Code', value: 'roocode', available: true, successLabel: 'Zoo Code', skillsDir: '.roo' },
     { name: 'Trae', value: 'trae', available: true, successLabel: 'Trae', skillsDir: '.trae' },
-    { name: 'Windsurf', value: 'windsurf', available: true, successLabel: 'Windsurf', skillsDir: '.windsurf' },
-    { name: 'AGENTS.md (works with Amp, VS Code, …)', value: 'agents', available: false, successLabel: 'your AGENTS.md-compatible assistant' }
+    { name: 'ZCode', value: 'zcode', available: true, successLabel: 'ZCode', skillsDir: '.zcode' },
+    // Vendor-neutral target for assistants that read the shared `.agents` root.
+    // Detection keys off `.agents/skills` rather than the bare root: frameworks use
+    // `.agents/` for more than skills, so the root alone says nothing about skills.
+    // A project that does keep skills there is a project this target fits, the same
+    // way `.claude/` selects Claude Code — the signal is the user's setup, not
+    // OpenSpec's own files.
+    { name: 'Shared .agents skills', value: 'agents', available: true, successLabel: 'shared .agents skills', skillsDir: '.agents', detectionPaths: ['.agents/skills'] }
 ];
+/**
+ * Retired tool ids that still resolve, so a rebrand does not break scripted
+ * `--tools` invocations. Windsurf was rebranded to Devin Desktop on
+ * 2026-06-02 and its config directory moved from `.windsurf/` to `.devin/`;
+ * `--tools windsurf` therefore configures `devin`.
+ */
+export const TOOL_ID_ALIASES = {
+    windsurf: 'devin',
+};
+/**
+ * Resolves a tool id through TOOL_ID_ALIASES, leaving current ids untouched.
+ */
+export function resolveToolIdAlias(toolId) {
+    return TOOL_ID_ALIASES[toolId] ?? toolId;
+}
 //# sourceMappingURL=config.js.map

package/dist/core/file-state.js

@@ -1,5 +1,6 @@
 import * as nodeFs from 'node:fs';
 import * as path from 'node:path';
+import { randomUUID } from 'node:crypto';
 import { FileSystemUtils } from '../utils/file-system.js';
 import { StoreError } from './store/errors.js';
 const fs = nodeFs.promises;
@@ -19,9 +20,15 @@ export function makeLockErrorFactory(data) {
         });
     };
 }
-const STALE_LOCK_THRESHOLD_MS = 30_000;
 const LOCK_DEADLINE_MS = 5000;
 const LOCK_POLL_MS = 25;
+const PRIVATE_FILE_MODE = 0o600;
+const lockOwnership = new WeakMap();
+function isUnsupportedSyncError(error) {
+    return (isNodeErrorCode(error, 'EINVAL') ||
+        isNodeErrorCode(error, 'ENOTSUP') ||
+        isNodeErrorCode(error, 'ENOSYS'));
+}
 export function isNodeErrorCode(error, code) {
     return (typeof error === 'object' &&
         error !== null &&
@@ -56,7 +63,10 @@ export async function writeFileAtomically(filePath, content) {
     await FileSystemUtils.createDirectory(dirPath);
     const tempPath = path.join(dirPath, `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`);
     try {
-        await fs.writeFile(tempPath, content, 'utf-8');
+        await fs.writeFile(tempPath, content, {
+            encoding: 'utf-8',
+            mode: PRIVATE_FILE_MODE,
+        });
         await fs.rename(tempPath, filePath);
     }
     catch (error) {
@@ -74,39 +84,61 @@ export async function acquireFileLock(options) {
     const deadline = Date.now() + LOCK_DEADLINE_MS;
     while (true) {
         try {
-            return await fs.open(lockPath, 'wx');
+            const lock = await fs.open(lockPath, 'wx', PRIVATE_FILE_MODE);
+            const ownershipToken = `${process.pid}:${randomUUID()}`;
+            try {
+                await lock.writeFile(ownershipToken, 'utf-8');
+                try {
+                    await lock.sync();
+                }
+                catch (error) {
+                    // Some FUSE and network filesystems support exclusive lock files but
+                    // explicitly do not implement fsync. The token is still visible to
+                    // cooperating processes, so do not make those projects unusable.
+                    if (!isUnsupportedSyncError(error)) {
+                        throw error;
+                    }
+                }
+            }
+            catch (error) {
+                await lock.close().catch(() => undefined);
+                await fs.rm(lockPath, { force: true }).catch(() => undefined);
+                throw error;
+            }
+            lockOwnership.set(lock, ownershipToken);
+            return lock;
         }
         catch (error) {
             if (!isNodeErrorCode(error, 'EEXIST')) {
                 // A permission or filesystem problem, not contention - say so.
                 throw errorFor('create-failed', { lockPath, cause: error });
             }
-            // A crashed process leaves the lock behind forever; state-file
-            // writes are sub-second, so an old lock is an orphan - steal it.
-            let staleStolen = false;
-            try {
-                const lockStat = await fs.stat(lockPath);
-                if (Date.now() - lockStat.mtimeMs > STALE_LOCK_THRESHOLD_MS) {
-                    await fs.rm(lockPath, { force: true });
-                    staleStolen = true;
-                }
-            }
-            catch {
-                // The holder released between open and stat - retry, but stay
-                // bounded: a persistently failing stat (EPERM, delete-pending)
-                // must hit the deadline instead of spinning forever.
-            }
-            if (!staleStolen) {
-                if (Date.now() >= deadline) {
-                    throw errorFor('timeout', { lockPath });
-                }
-                await sleep(LOCK_POLL_MS);
+            // Never steal by age: unlinking a supposedly stale path can race with
+            // its replacement and erase a live owner's lock. The timeout diagnostic
+            // gives the user an explicit recovery path for genuinely orphaned locks.
+            if (Date.now() >= deadline) {
+                throw errorFor('timeout', { lockPath });
             }
+            await sleep(LOCK_POLL_MS);
         }
     }
 }
 export async function releaseFileLock(lock, lockPath) {
+    const ownershipToken = lockOwnership.get(lock);
+    lockOwnership.delete(lock);
     await lock.close().catch(() => undefined);
-    await fs.rm(lockPath, { force: true }).catch(() => undefined);
+    if (ownershipToken === undefined) {
+        return;
+    }
+    try {
+        const currentToken = await fs.readFile(lockPath, 'utf-8');
+        if (currentToken === ownershipToken) {
+            await fs.rm(lockPath, { force: true });
+        }
+    }
+    catch {
+        // The lock was already removed or replaced with an unreadable path.
+        // In either case, this owner must not remove anything else.
+    }
 }
 //# sourceMappingURL=file-state.js.map

package/dist/core/github-copilot/cloud-agent.d.ts

@@ -0,0 +1,95 @@
+/**
+ * GitHub Copilot Cloud Agent Support
+ *
+ * Generates copilot-setup-steps.yml and .github/agents/openspec.agent.md
+ * when the github-copilot tool is selected during init/update.
+ * These files enable the GitHub Copilot coding agent (cloud) to use the
+ * OpenSpec CLI in its ephemeral dev environment.
+ */
+/**
+ * Check if a tool list includes github-copilot.
+ */
+export declare function includesGitHubCopilot(toolIds: string[]): boolean;
+/**
+ * Generate the copilot-setup-steps.yml workflow file content.
+ * This workflow pre-installs the OpenSpec CLI in the Copilot coding agent's
+ * ephemeral GitHub Actions environment.
+ */
+export declare function generateCopilotSetupSteps(): string;
+/**
+ * Generate the .github/agents/openspec.agent.md custom agent file content.
+ * This tells the GitHub Copilot coding agent how to use the OpenSpec CLI.
+ */
+export declare function generateCopilotAgentFile(): string;
+/**
+ * File paths (relative to project root) for the generated files.
+ */
+export declare const COPILOT_CLOUD_FILES: {
+    readonly setupSteps: string;
+    readonly agent: string;
+};
+/**
+ * Reconcile Copilot cloud agent files in the project directory.
+ * Creates missing files and refreshes recognized legacy generated files while
+ * preserving current generated content and user customizations.
+ *
+ * @returns Object indicating which files were written.
+ */
+export declare function writeCopilotCloudFiles(projectPath: string): Promise<{
+    setupStepsWritten: boolean;
+    agentWritten: boolean;
+}>;
+/**
+ * Remove copilot cloud agent files from the project directory.
+ * Used when github-copilot is deselected.
+ *
+ * @returns Number of files removed.
+ */
+export declare function removeCopilotCloudFiles(projectPath: string): Promise<number>;
+/**
+ * Read the persisted opt-in for Copilot cloud-file generation.
+ *
+ * Tri-state: `true` (opted in), `false` (explicitly opted out), or `undefined`
+ * (never decided). A malformed value is treated as undecided rather than an
+ * error, matching how {@link readProjectConfig} degrades on bad fields.
+ */
+export declare function readCopilotCloudOptIn(projectPath: string): boolean | undefined;
+/**
+ * True when a managed Copilot cloud file (the current generation or a
+ * recognized legacy one) already exists. Projects created before the opt-in
+ * prompt existed are treated as implicitly opted in, so `openspec update`
+ * keeps their files current instead of silently abandoning them.
+ */
+export declare function hasExistingManagedCloudFiles(projectPath: string): Promise<boolean>;
+/**
+ * Effective decision on whether to generate/refresh Copilot cloud files.
+ * An explicit opt-in or opt-out always wins; when undecided, fall back to
+ * whether managed files already exist (the migration path above).
+ */
+export declare function isCopilotCloudEnabled(projectPath: string): Promise<boolean>;
+/**
+ * Persist the Copilot cloud opt-in into openspec/config.yaml.
+ *
+ * Uses the YAML document model rather than a re-serialize so the user's
+ * existing comments, ordering, and formatting survive untouched — the config
+ * file is hand-authored and heavily commented, so a lossy round-trip would be
+ * its own source of toil. No-op when no config file exists yet (init creates it
+ * before this is called); the caller treats persistence failures as non-fatal.
+ */
+export declare function persistCopilotCloudOptIn(projectPath: string, value: boolean): Promise<void>;
+/**
+ * Return the managed cloud-file paths (relative to the project root) that
+ * currently hold user-owned, non-managed content — i.e. files OpenSpec will
+ * deliberately leave untouched. Used to tell an opted-in user that we preserved
+ * their existing file rather than silently doing nothing, which is the honest
+ * answer to "will this affect my existing Copilot cloud setup?".
+ */
+export declare function findUnmanagedCloudFiles(projectPath: string): Promise<string[]>;
+/**
+ * Return the managed cloud-file paths (relative to the project root) that
+ * currently exist and hold OpenSpec-generated content. Callers report this
+ * rather than the intended paths, so output never claims a file that a write
+ * skipped (user already owns it) or that reconciliation removed.
+ */
+export declare function listManagedCloudFiles(projectPath: string): Promise<string[]>;
+//# sourceMappingURL=cloud-agent.d.ts.map