@fission-ai/openspec 1.3.0 → 1.4.0

package/dist/core/workspace/skills.js

@@ -0,0 +1,334 @@
+import * as nodeFs from 'node:fs';
+import { createRequire } from 'node:module';
+import { FileSystemUtils } from '../../utils/file-system.js';
+import { transformToHyphenCommands } from '../../utils/command-references.js';
+import { AI_TOOLS } from '../config.js';
+import { getGlobalConfig } from '../global-config.js';
+import { getProfileWorkflows } from '../profiles.js';
+import { generateSkillContent, getSkillTemplates, getToolSkillStatus, getToolsWithSkillsDir, extractGeneratedByVersion, } from '../shared/index.js';
+const require = createRequire(import.meta.url);
+const { version: OPENSPEC_VERSION } = require('../../../package.json');
+const fs = nodeFs.promises;
+function resolveWorkspaceSkillProfileContext() {
+    const globalConfig = getGlobalConfig();
+    const profile = globalConfig.profile ?? 'core';
+    const delivery = globalConfig.delivery ?? 'both';
+    const workflowIds = [...getProfileWorkflows(profile, globalConfig.workflows)];
+    const deliveryNotice = delivery === 'skills'
+        ? null
+        : 'Workspace setup installs skills only; workspace command generation is not part of this slice.';
+    return {
+        profile,
+        delivery,
+        workflowIds,
+        deliveryNotice,
+    };
+}
+export function getCurrentWorkspaceSkillProfileSelection() {
+    const profileContext = resolveWorkspaceSkillProfileContext();
+    return {
+        profile: profileContext.profile,
+        delivery: profileContext.delivery,
+        workflow_ids: profileContext.workflowIds,
+    };
+}
+function arraysEqual(left, right) {
+    const leftValues = left ?? [];
+    if (leftValues.length !== right.length) {
+        return false;
+    }
+    const leftSet = new Set(leftValues);
+    const rightSet = new Set(right);
+    if (leftSet.size !== rightSet.size) {
+        return false;
+    }
+    return [...leftSet].every((value) => rightSet.has(value));
+}
+export function hasWorkspaceSkillProfileDrift(state) {
+    const workspaceSkills = state?.workspace_skills;
+    if (!workspaceSkills) {
+        return false;
+    }
+    const current = getCurrentWorkspaceSkillProfileSelection();
+    return (workspaceSkills.last_applied_profile !== current.profile ||
+        workspaceSkills.last_applied_delivery !== current.delivery ||
+        !arraysEqual(workspaceSkills.last_applied_workflow_ids, current.workflow_ids));
+}
+function makeBaseWorkspaceSkillReport(selectedAgentIds, profileContext = resolveWorkspaceSkillProfileContext()) {
+    return {
+        profile: profileContext.profile,
+        delivery: profileContext.delivery,
+        workflow_ids: profileContext.workflowIds,
+        selected_agents: selectedAgentIds,
+        skills_only: true,
+        delivery_notice: profileContext.deliveryNotice,
+        generated: [],
+        added: [],
+        refreshed: [],
+        removed: [],
+        skipped: [],
+        failed: [],
+    };
+}
+export function getWorkspaceSkillCapableTools() {
+    return AI_TOOLS.filter((tool) => Boolean(tool.skillsDir));
+}
+export function getWorkspaceSkillToolIds() {
+    return getToolsWithSkillsDir();
+}
+export function parseWorkspaceSkillToolsValue(rawTools) {
+    const raw = rawTools.trim();
+    if (raw.length === 0) {
+        throw new Error('The --tools option requires a value. Use "all", "none", or a comma-separated list of agent IDs.');
+    }
+    const availableTools = getWorkspaceSkillToolIds();
+    const availableSet = new Set(availableTools);
+    const availableList = ['all', 'none', ...availableTools].join(', ');
+    const lowerRaw = raw.toLowerCase();
+    if (lowerRaw === 'all') {
+        return availableTools;
+    }
+    if (lowerRaw === 'none') {
+        return [];
+    }
+    const tokens = raw
+        .split(',')
+        .map((token) => token.trim())
+        .filter((token) => token.length > 0);
+    if (tokens.length === 0) {
+        throw new Error('The --tools option requires at least one agent ID when not using "all" or "none".');
+    }
+    const normalizedTokens = tokens.map((token) => token.toLowerCase());
+    if (normalizedTokens.some((token) => token === 'all' || token === 'none')) {
+        throw new Error('Cannot combine reserved values "all" or "none" with specific agent IDs.');
+    }
+    const invalidTokens = tokens.filter((_token, index) => !availableSet.has(normalizedTokens[index]));
+    if (invalidTokens.length > 0) {
+        throw new Error(`Invalid agent(s): ${invalidTokens.join(', ')}. Available values: ${availableList}`);
+    }
+    const deduped = [];
+    for (const token of normalizedTokens) {
+        if (!deduped.includes(token)) {
+            deduped.push(token);
+        }
+    }
+    return deduped;
+}
+export function createWorkspaceSkillSkippedReport(reason, message) {
+    const report = makeBaseWorkspaceSkillReport([]);
+    report.skipped.push({
+        reason,
+        message,
+    });
+    return report;
+}
+function getWorkspaceSkillTool(toolId) {
+    const tool = getWorkspaceSkillCapableTools().find((candidate) => candidate.value === toolId);
+    if (!tool) {
+        throw new Error(`Unknown workspace skill agent '${toolId}'.`);
+    }
+    return tool;
+}
+function getWorkspaceSkillDirectoryForTool(workspaceRoot, tool) {
+    return FileSystemUtils.joinPath(workspaceRoot, tool.skillsDir, 'skills');
+}
+export function getWorkspaceSkillDirectory(workspaceRoot, toolId) {
+    return getWorkspaceSkillDirectoryForTool(workspaceRoot, getWorkspaceSkillTool(toolId));
+}
+function makeAgentResult(workspaceRoot, tool, workflowIds) {
+    return {
+        tool_id: tool.value,
+        name: tool.name,
+        skills_path: getWorkspaceSkillDirectoryForTool(workspaceRoot, tool),
+        workflow_ids: workflowIds,
+    };
+}
+function getManagedWorkspaceSkillEntries() {
+    return getSkillTemplates().map(({ workflowId, dirName }) => ({ workflowId, dirName }));
+}
+async function pathExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isOpenSpecManagedSkillDir(skillDir) {
+    const skillFile = FileSystemUtils.joinPath(skillDir, 'SKILL.md');
+    return extractGeneratedByVersion(skillFile) !== null;
+}
+async function removeManagedWorkflowSkillDirs(workspaceRoot, tool, desiredWorkflowIds, reason) {
+    const desiredSet = new Set(desiredWorkflowIds);
+    const skillsDir = getWorkspaceSkillDirectoryForTool(workspaceRoot, tool);
+    const removedWorkflowIds = [];
+    for (const { workflowId, dirName } of getManagedWorkspaceSkillEntries()) {
+        if (desiredSet.has(workflowId)) {
+            continue;
+        }
+        const skillDir = FileSystemUtils.joinPath(skillsDir, dirName);
+        if (!(await pathExists(skillDir))) {
+            continue;
+        }
+        if (!isOpenSpecManagedSkillDir(skillDir)) {
+            continue;
+        }
+        await fs.rm(skillDir, { recursive: true, force: true });
+        removedWorkflowIds.push(workflowId);
+    }
+    if (removedWorkflowIds.length === 0) {
+        return null;
+    }
+    return {
+        ...makeAgentResult(workspaceRoot, tool, removedWorkflowIds),
+        reason,
+    };
+}
+export async function generateWorkspaceAgentSkills(workspaceRoot, selectedAgentIds) {
+    const profileContext = resolveWorkspaceSkillProfileContext();
+    const report = makeBaseWorkspaceSkillReport(selectedAgentIds, profileContext);
+    if (selectedAgentIds.length === 0) {
+        report.skipped.push({
+            reason: 'no_agents_selected',
+            message: 'No workspace agent skills were selected.',
+        });
+        return report;
+    }
+    const skillTemplates = getSkillTemplates(profileContext.workflowIds);
+    if (skillTemplates.length === 0) {
+        for (const toolId of selectedAgentIds) {
+            const tool = getWorkspaceSkillTool(toolId);
+            report.skipped.push({
+                tool_id: tool.value,
+                name: tool.name,
+                reason: 'no_profile_workflows',
+                message: 'The active global profile does not select any workflows.',
+            });
+        }
+        return report;
+    }
+    for (const toolId of selectedAgentIds) {
+        const tool = getWorkspaceSkillTool(toolId);
+        const wasConfigured = getToolSkillStatus(workspaceRoot, tool.value).configured;
+        try {
+            const skillsDir = getWorkspaceSkillDirectoryForTool(workspaceRoot, tool);
+            const transformer = tool.value === 'opencode' || tool.value === 'pi' ? transformToHyphenCommands : undefined;
+            for (const { template, dirName } of skillTemplates) {
+                const skillFile = FileSystemUtils.joinPath(skillsDir, dirName, 'SKILL.md');
+                const skillContent = generateSkillContent(template, OPENSPEC_VERSION, transformer);
+                await FileSystemUtils.writeFile(skillFile, skillContent);
+            }
+            const result = makeAgentResult(workspaceRoot, tool, profileContext.workflowIds);
+            if (wasConfigured) {
+                report.refreshed.push(result);
+            }
+            else {
+                report.generated.push(result);
+            }
+        }
+        catch (error) {
+            report.failed.push({
+                tool_id: tool.value,
+                name: tool.name,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return report;
+}
+export async function updateWorkspaceAgentSkills(workspaceRoot, selectedAgentIds, previousSkillState) {
+    const profileContext = resolveWorkspaceSkillProfileContext();
+    const report = makeBaseWorkspaceSkillReport(selectedAgentIds, profileContext);
+    const previousSelectedAgentIds = previousSkillState?.selected_agents ?? [];
+    const previousSelectedSet = new Set(previousSelectedAgentIds);
+    const selectedSet = new Set(selectedAgentIds);
+    const skillTemplates = getSkillTemplates(profileContext.workflowIds);
+    for (const toolId of previousSelectedAgentIds) {
+        if (selectedSet.has(toolId)) {
+            continue;
+        }
+        const tool = getWorkspaceSkillTool(toolId);
+        try {
+            const removed = await removeManagedWorkflowSkillDirs(workspaceRoot, tool, [], 'agent_unselected');
+            if (removed) {
+                report.removed.push(removed);
+            }
+        }
+        catch (error) {
+            report.failed.push({
+                tool_id: tool.value,
+                name: tool.name,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    if (selectedAgentIds.length === 0) {
+        if (report.removed.length === 0) {
+            report.skipped.push({
+                reason: previousSkillState ? 'no_agents_selected' : 'no_stored_agent_selection',
+                message: previousSkillState
+                    ? 'No workspace agent skills were selected.'
+                    : 'No workspace agent skill selection is stored. Pass --tools <ids> to install skills.',
+            });
+        }
+        return report;
+    }
+    if (skillTemplates.length === 0) {
+        for (const toolId of selectedAgentIds) {
+            const tool = getWorkspaceSkillTool(toolId);
+            try {
+                const removed = await removeManagedWorkflowSkillDirs(workspaceRoot, tool, [], 'workflow_unselected');
+                if (removed) {
+                    report.removed.push(removed);
+                }
+            }
+            catch (error) {
+                report.failed.push({
+                    tool_id: tool.value,
+                    name: tool.name,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            report.skipped.push({
+                tool_id: tool.value,
+                name: tool.name,
+                reason: 'no_profile_workflows',
+                message: 'The active global profile does not select any workflows.',
+            });
+        }
+        return report;
+    }
+    for (const toolId of selectedAgentIds) {
+        const tool = getWorkspaceSkillTool(toolId);
+        try {
+            const skillsDir = getWorkspaceSkillDirectoryForTool(workspaceRoot, tool);
+            const transformer = tool.value === 'opencode' || tool.value === 'pi' ? transformToHyphenCommands : undefined;
+            for (const { template, dirName } of skillTemplates) {
+                const skillFile = FileSystemUtils.joinPath(skillsDir, dirName, 'SKILL.md');
+                const skillContent = generateSkillContent(template, OPENSPEC_VERSION, transformer);
+                await FileSystemUtils.writeFile(skillFile, skillContent);
+            }
+            const removed = await removeManagedWorkflowSkillDirs(workspaceRoot, tool, profileContext.workflowIds, 'workflow_unselected');
+            if (removed) {
+                report.removed.push(removed);
+            }
+            const result = makeAgentResult(workspaceRoot, tool, profileContext.workflowIds);
+            if (previousSelectedSet.has(toolId)) {
+                report.refreshed.push(result);
+            }
+            else {
+                report.added.push(result);
+            }
+        }
+        catch (error) {
+            report.failed.push({
+                tool_id: tool.value,
+                name: tool.name,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return report;
+}
+//# sourceMappingURL=skills.js.map

package/dist/core/workspace/state-io.d.ts

@@ -0,0 +1,10 @@
+import { type WorkspaceViewState } from './foundation.js';
+export declare function isWorkspaceRoot(candidateRoot: string): Promise<boolean>;
+export declare function findWorkspaceRoot(startPath?: string): Promise<string | null>;
+export declare function workspaceStateFileExistsSync(workspaceRoot: string): boolean;
+export declare function readWorkspaceViewState(workspaceRoot: string): Promise<WorkspaceViewState>;
+export declare function readWorkspaceViewStateSync(workspaceRoot: string): WorkspaceViewState | null;
+export declare function readOptionalWorkspaceViewState(workspaceRoot: string): Promise<WorkspaceViewState | null>;
+export declare function writeWorkspaceViewState(workspaceRoot: string, state: WorkspaceViewState): Promise<void>;
+export declare function workspaceChangesDirExists(workspaceRoot: string): Promise<boolean>;
+//# sourceMappingURL=state-io.d.ts.map

package/dist/core/workspace/state-io.js

@@ -0,0 +1,119 @@
+import * as nodeFs from 'node:fs';
+import * as path from 'node:path';
+import { FileSystemUtils } from '../../utils/file-system.js';
+import { getWorkspaceChangesDir, getWorkspaceViewStatePath, parseWorkspaceViewState, serializeWorkspaceViewState, } from './foundation.js';
+import { getWorkspaceLegacyLocalStatePath, getWorkspaceLegacySharedStatePath, parseWorkspaceLocalState, parseWorkspaceSharedState, workspaceStatePartsToViewState, } from './legacy-state.js';
+const fs = nodeFs.promises;
+async function pathIsFile(filePath) {
+    try {
+        return (await fs.stat(filePath)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function pathIsDirectory(dirPath) {
+    try {
+        return (await fs.stat(dirPath)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function pathExistsAsFile(filePath) {
+    try {
+        return nodeFs.statSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function isFileNotFoundError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code === 'ENOENT');
+}
+async function getSearchStartDirectory(startPath) {
+    const resolvedStart = path.resolve(startPath);
+    try {
+        const stats = await fs.stat(resolvedStart);
+        const searchStart = stats.isDirectory() ? resolvedStart : path.dirname(resolvedStart);
+        return FileSystemUtils.canonicalizeExistingPath(searchStart);
+    }
+    catch {
+        return resolvedStart;
+    }
+}
+export async function isWorkspaceRoot(candidateRoot) {
+    return ((await pathIsFile(getWorkspaceViewStatePath(candidateRoot))) ||
+        (await pathIsFile(getWorkspaceLegacySharedStatePath(candidateRoot))));
+}
+export async function findWorkspaceRoot(startPath = process.cwd()) {
+    let currentDir = await getSearchStartDirectory(startPath);
+    while (true) {
+        if (await isWorkspaceRoot(currentDir)) {
+            return FileSystemUtils.canonicalizeExistingPath(currentDir);
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            return null;
+        }
+        currentDir = parentDir;
+    }
+}
+export function workspaceStateFileExistsSync(workspaceRoot) {
+    return (pathExistsAsFile(getWorkspaceViewStatePath(workspaceRoot)) ||
+        pathExistsAsFile(getWorkspaceLegacySharedStatePath(workspaceRoot)));
+}
+export async function readWorkspaceViewState(workspaceRoot) {
+    const viewStatePath = getWorkspaceViewStatePath(workspaceRoot);
+    if (await pathIsFile(viewStatePath)) {
+        return parseWorkspaceViewState(await fs.readFile(viewStatePath, 'utf-8'));
+    }
+    const legacySharedState = parseWorkspaceSharedState(await fs.readFile(getWorkspaceLegacySharedStatePath(workspaceRoot), 'utf-8'));
+    let legacyLocalState = null;
+    try {
+        legacyLocalState = parseWorkspaceLocalState(await fs.readFile(getWorkspaceLegacyLocalStatePath(workspaceRoot), 'utf-8'));
+    }
+    catch (error) {
+        if (!isFileNotFoundError(error)) {
+            throw error;
+        }
+    }
+    return workspaceStatePartsToViewState(legacySharedState, legacyLocalState);
+}
+export function readWorkspaceViewStateSync(workspaceRoot) {
+    const viewStatePath = getWorkspaceViewStatePath(workspaceRoot);
+    if (pathExistsAsFile(viewStatePath)) {
+        return parseWorkspaceViewState(nodeFs.readFileSync(viewStatePath, 'utf-8'));
+    }
+    const legacySharedPath = getWorkspaceLegacySharedStatePath(workspaceRoot);
+    if (!pathExistsAsFile(legacySharedPath)) {
+        return null;
+    }
+    const legacySharedState = parseWorkspaceSharedState(nodeFs.readFileSync(legacySharedPath, 'utf-8'));
+    const legacyLocalPath = getWorkspaceLegacyLocalStatePath(workspaceRoot);
+    const legacyLocalState = pathExistsAsFile(legacyLocalPath)
+        ? parseWorkspaceLocalState(nodeFs.readFileSync(legacyLocalPath, 'utf-8'))
+        : null;
+    return workspaceStatePartsToViewState(legacySharedState, legacyLocalState);
+}
+export async function readOptionalWorkspaceViewState(workspaceRoot) {
+    try {
+        return await readWorkspaceViewState(workspaceRoot);
+    }
+    catch (error) {
+        if (isFileNotFoundError(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function writeWorkspaceViewState(workspaceRoot, state) {
+    await FileSystemUtils.writeFile(getWorkspaceViewStatePath(workspaceRoot), serializeWorkspaceViewState(state));
+}
+export async function workspaceChangesDirExists(workspaceRoot) {
+    return pathIsDirectory(getWorkspaceChangesDir(workspaceRoot));
+}
+//# sourceMappingURL=state-io.js.map

package/dist/telemetry/config.d.ts

@@ -1,3 +1,5 @@
+export declare const CONFIG_DIR_NAME = "openspec";
+export declare const CONFIG_FILE_NAME = "config.json";
 export interface TelemetryConfig {
     anonymousId?: string;
     noticeSeen?: boolean;
@@ -8,7 +10,11 @@ export interface GlobalConfig {
 }
 /**
  * Get the path to the global config file.
- * Uses ~/.config/openspec/config.json on all platforms.
+ * Follows XDG Base Directory Specification and platform conventions.
+ *
+ * - All platforms: $XDG_CONFIG_HOME/openspec/ if XDG_CONFIG_HOME is set
+ * - Unix/macOS fallback: ~/.config/openspec/
+ * - Windows fallback: %APPDATA%/openspec/
  */
 export declare function getConfigPath(): string;
 /**

package/dist/telemetry/config.js

@@ -1,17 +1,96 @@
 /**
  * Global configuration for telemetry state.
- * Stores anonymous ID and notice-seen flag in ~/.config/openspec/config.json
+ * Stores anonymous ID and notice-seen flag in the platform-appropriate config directory.
  */
 import { promises as fs } from 'fs';
 import path from 'path';
 import os from 'os';
+import { GLOBAL_CONFIG_DIR_NAME, GLOBAL_CONFIG_FILE_NAME, getGlobalConfigDir, } from '../core/global-config.js';
+// Constants
+export const CONFIG_DIR_NAME = GLOBAL_CONFIG_DIR_NAME;
+export const CONFIG_FILE_NAME = GLOBAL_CONFIG_FILE_NAME;
+function getConfigDir() {
+    return getGlobalConfigDir();
+}
+function getLegacyConfigPath() {
+    return path.join(os.homedir(), '.config', CONFIG_DIR_NAME, CONFIG_FILE_NAME);
+}
+async function readConfigFile(configPath) {
+    try {
+        const content = await fs.readFile(configPath, 'utf-8');
+        return { status: 'ok', config: JSON.parse(content) };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return { status: 'missing' };
+        }
+        // If parse fails or another read error occurs, ignore the file.
+        return { status: 'invalid', config: {} };
+    }
+}
+async function writeConfigFile(configPath, config) {
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2) + '\n');
+}
+function hasMissingTelemetryFields(config) {
+    const telemetry = config.telemetry;
+    return (!telemetry ||
+        telemetry.anonymousId === undefined ||
+        telemetry.noticeSeen === undefined);
+}
+function mergeLegacyTelemetry(config, legacyConfig) {
+    const legacyTelemetry = legacyConfig.telemetry;
+    if (!legacyTelemetry) {
+        return undefined;
+    }
+    const currentTelemetry = config.telemetry ?? {};
+    const shouldMigrate = (currentTelemetry.anonymousId === undefined && legacyTelemetry.anonymousId !== undefined) ||
+        (currentTelemetry.noticeSeen === undefined && legacyTelemetry.noticeSeen !== undefined);
+    if (!shouldMigrate) {
+        return undefined;
+    }
+    return {
+        ...config,
+        telemetry: {
+            ...legacyTelemetry,
+            ...currentTelemetry,
+        },
+    };
+}
+async function migrateLegacyTelemetryConfig(configPath, config, persist) {
+    const legacyConfigPath = getLegacyConfigPath();
+    if (path.resolve(configPath) === path.resolve(legacyConfigPath) || !hasMissingTelemetryFields(config)) {
+        return config;
+    }
+    const legacyRead = await readConfigFile(legacyConfigPath);
+    if (legacyRead.status !== 'ok') {
+        return config;
+    }
+    const migrated = mergeLegacyTelemetry(config, legacyRead.config);
+    if (!migrated) {
+        return config;
+    }
+    if (persist) {
+        try {
+            await writeConfigFile(configPath, migrated);
+        }
+        catch {
+            // Preserve telemetry for this run even if the one-time migration cannot be persisted.
+        }
+    }
+    return migrated;
+}
 /**
  * Get the path to the global config file.
- * Uses ~/.config/openspec/config.json on all platforms.
+ * Follows XDG Base Directory Specification and platform conventions.
+ *
+ * - All platforms: $XDG_CONFIG_HOME/openspec/ if XDG_CONFIG_HOME is set
+ * - Unix/macOS fallback: ~/.config/openspec/
+ * - Windows fallback: %APPDATA%/openspec/
  */
 export function getConfigPath() {
-    const configDir = path.join(os.homedir(), '.config', 'openspec');
-    return path.join(configDir, 'config.json');
+    const configDir = getConfigDir();
+    return path.join(configDir, CONFIG_FILE_NAME);
 }
 /**
  * Read the global config file.
@@ -19,17 +98,9 @@ export function getConfigPath() {
  */
 export async function readConfig() {
     const configPath = getConfigPath();
-    try {
-        const content = await fs.readFile(configPath, 'utf-8');
-        return JSON.parse(content);
-    }
-    catch (error) {
-        if (error.code === 'ENOENT') {
-            return {};
-        }
-        // If parse fails or other error, return empty config
-        return {};
-    }
+    const read = await readConfigFile(configPath);
+    const config = read.status === 'ok' ? read.config : {};
+    return migrateLegacyTelemetryConfig(configPath, config, read.status !== 'invalid');
 }
 /**
  * Write to the global config file.
@@ -37,9 +108,6 @@ export async function readConfig() {
  */
 export async function writeConfig(updates) {
     const configPath = getConfigPath();
-    const configDir = path.dirname(configPath);
-    // Ensure directory exists
-    await fs.mkdir(configDir, { recursive: true });
     // Read existing config and merge
     const existing = await readConfig();
     const merged = { ...existing, ...updates };
@@ -47,7 +115,7 @@ export async function writeConfig(updates) {
     if (updates.telemetry && existing.telemetry) {
         merged.telemetry = { ...existing.telemetry, ...updates.telemetry };
     }
-    await fs.writeFile(configPath, JSON.stringify(merged, null, 2) + '\n');
+    await writeConfigFile(configPath, merged);
 }
 /**
  * Get the telemetry config section.

package/dist/telemetry/index.js

@@ -16,8 +16,21 @@ import { getTelemetryConfig, updateTelemetryConfig } from './config.js';
 const POSTHOG_API_KEY = 'phc_Hthu8YvaIJ9QaFKyTG4TbVwkbd5ktcAFzVTKeMmoW2g';
 // Using reverse proxy to avoid ad blockers and keep traffic on our domain
 const POSTHOG_HOST = 'https://edge.openspec.dev';
+const TELEMETRY_REQUEST_TIMEOUT_MS = 1000;
 let posthogClient = null;
 let anonymousId = null;
+async function safeTelemetryFetch(url, options) {
+    try {
+        const response = await fetch(url, options);
+        if (response.ok) {
+            return response;
+        }
+    }
+    catch {
+        // Silent failure - telemetry should never surface network noise
+    }
+    return new Response(null, { status: 204 });
+}
 /**
  * Check if telemetry is enabled.
  *
@@ -71,6 +84,12 @@ function getClient() {
             host: POSTHOG_HOST,
             flushAt: 1, // Send immediately, don't batch
             flushInterval: 0, // No timer-based flushing
+            fetchRetryCount: 0,
+            requestTimeout: TELEMETRY_REQUEST_TIMEOUT_MS,
+            preloadFeatureFlags: false,
+            disableRemoteConfig: true,
+            disableSurveys: true,
+            fetch: safeTelemetryFetch,
         });
     }
     return posthogClient;

package/dist/utils/change-metadata.d.ts

@@ -1,4 +1,4 @@
-import { type ChangeMetadata } from '../core/artifact-graph/types.js';
+import { type ChangeMetadata } from '../core/change-metadata/index.js';
 /**
  * Error thrown when change metadata validation fails.
  */
@@ -34,6 +34,9 @@ export declare function writeChangeMetadata(changeDir: string, metadata: ChangeM
  * @throws ChangeMetadataError if the file exists but is invalid
  */
 export declare function readChangeMetadata(changeDir: string, projectRoot?: string): ChangeMetadata | null;
+export interface ResolveSchemaForChangeOptions {
+    metadata?: ChangeMetadata | null;
+}
 /**
  * Resolves the schema for a change, with explicit override taking precedence.
  *
@@ -47,5 +50,5 @@ export declare function readChangeMetadata(changeDir: string, projectRoot?: stri
  * @param explicitSchema - Optional explicit schema override
  * @returns The resolved schema name
  */
-export declare function resolveSchemaForChange(changeDir: string, explicitSchema?: string): string;
+export declare function resolveSchemaForChange(changeDir: string, explicitSchema?: string, projectRootOverride?: string, options?: ResolveSchemaForChangeOptions): string;
 //# sourceMappingURL=change-metadata.d.ts.map