@devtrack-solution/codesdd 1.2.2

package/dist/core/sdd/workspace-schemas.js

@@ -0,0 +1,254 @@
+import { z } from 'zod';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+export const workspaceFeatureIdSchema = z.string().regex(/^FEAT-\d{4}$/);
+export const workspaceGateSchema = z.object({
+    status: z.enum(['nao_exigida', 'rascunho', 'pronta', 'aprovada']).default('rascunho'),
+    approved_at: z.string().optional(),
+    approved_by: z.string().optional(),
+    note: z.string().optional(),
+});
+export const workspaceSpecSchema = z.object({
+    schema_version: z.literal(1),
+    feature_id: workspaceFeatureIdSchema,
+    title: z.string().min(10),
+    origin: z.object({
+        type: z.enum(['epic', 'radar', 'direct', 'fgap', 'td']),
+        ref: z.string(),
+    }),
+    objective: z.string().min(100),
+    expected_outcome: z.string().min(50),
+    system_impact: z.string().min(30),
+    acceptance_refs: z.array(z.string()).min(1),
+    gates: z.object({
+        proposta: workspaceGateSchema,
+        planejamento: workspaceGateSchema,
+        tarefas: workspaceGateSchema,
+    }),
+    compliance_context: z
+        .object({
+        jurisdictions: z.array(z.string()).default([]),
+        data_classes: z.array(z.string()).default([]),
+        source_refs: z.array(z.string()).default([]),
+        legal_review_required: z.boolean().default(false),
+        legal_review_notes: z.string().optional(),
+    })
+        .optional(),
+    created_at: z.string().datetime(),
+    updated_at: z.string().datetime(),
+});
+export const workspacePlanSchema = z.object({
+    schema_version: z.literal(1),
+    feature_id: workspaceFeatureIdSchema,
+    architectural_impact: z.object({
+        description: z.string(),
+        affected_modules: z.array(z.string()),
+    }),
+    frontend_impact: z.object({
+        status: z.enum(['unknown', 'none', 'required']),
+        description: z.string(),
+    }),
+    affected_contracts: z.array(z.object({
+        name: z.string(),
+        change_type: z.string(),
+    })),
+    quality_strategy: z.object({
+        unit_target: z.number(),
+        integration_target: z.number(),
+        approach: z.string(),
+    }),
+    suggested_skills: z.array(z.string()),
+    privacy_controls: z
+        .object({
+        source_registry_refs: z.array(z.string()).default([]),
+        jurisdiction_profiles: z.array(z.string()).default([]),
+        control_ids: z.array(z.string()).default([]),
+        legal_review_gate: z.enum(['required', 'conditional', 'not_required']).default('conditional'),
+        unresolved_legal_questions: z.array(z.string()).default([]),
+    })
+        .optional(),
+    skill_conformance: z
+        .object({
+        selected_skills: z.array(z.string()).default([]),
+        required_skills: z.array(z.string()).default([]),
+        detected_conflicts: z.array(z.string()).default([]),
+        resolution_adr_ref: z.string().optional(),
+        architecture_tree_ascii: z.string().optional(),
+    })
+        .optional(),
+});
+export const workspaceTaskSchema = z.object({
+    id: z.string(),
+    phase: z.enum(['preparation', 'implementation', 'testing', 'documentation', 'finalization']),
+    title: z.string(),
+    description: z.string(),
+    files_touched: z.array(z.string()),
+    test_scripts: z.array(z.object({
+        command: z.string(),
+        type: z.string(),
+        expected: z.string(),
+    })),
+    acceptance: z.string(),
+    status: z.enum(['pending', 'in_progress', 'done', 'skipped']),
+});
+export const workspaceTasksSchema = z.object({
+    schema_version: z.literal(1),
+    feature_id: workspaceFeatureIdSchema,
+    tasks: z.array(workspaceTaskSchema).min(5),
+});
+export const workspaceChangelogSchema = z.object({
+    schema_version: z.literal(1),
+    feature_id: workspaceFeatureIdSchema,
+    entries: z.array(z.object({
+        timestamp: z.string().datetime(),
+        action: z.string(),
+        details: z.string(),
+        refs: z.array(z.string()).default([]),
+    })),
+});
+export const workspaceTraceabilityCodeRefSchema = z.object({
+    path: z.string().min(1),
+    symbols: z.array(z.string()).default([]),
+    note: z.string().optional(),
+});
+export const workspaceTraceabilityTestRefSchema = z.object({
+    id: z.string().min(1),
+    path: z.string().optional(),
+    kind: z.string().optional(),
+    note: z.string().optional(),
+});
+export const workspaceTraceabilityRequirementSchema = z.object({
+    requirement_ref: z.string().min(1),
+    requirement: z.string().min(10),
+    code_refs: z.array(workspaceTraceabilityCodeRefSchema).min(1),
+    test_refs: z.array(workspaceTraceabilityTestRefSchema).min(1),
+    semantic_coverage: z
+        .enum(['covered', 'partial', 'not_covered', 'not_applicable'])
+        .default('covered'),
+    changelog_refs: z.array(z.string().min(1)).min(1),
+    evidence_refs: z.array(z.string().min(1)).min(1),
+});
+export const workspaceTraceabilitySchema = z.object({
+    spec_anchor: z.object({
+        spec_updated_at: z.string().default(''),
+        changelog_refs: z.array(z.string().min(1)).default([]),
+    }),
+    requirements: z.array(workspaceTraceabilityRequirementSchema).default([]),
+});
+export const workspaceQualitySchema = z.object({
+    schema_version: z.literal(1),
+    feature_id: workspaceFeatureIdSchema,
+    coverage_targets: z.object({
+        unit: z.number(),
+        integration: z.number(),
+        modules: z.record(z.string(), z.number()).optional(),
+    }),
+    validation_strategies: z.array(z.object({
+        name: z.string(),
+        command: z.string(),
+        expected: z.string(),
+    })),
+    evidence_log: z.array(z.object({
+        timestamp: z.string(),
+        kind: z.string(),
+        result: z.string(),
+        artifact: z.string().optional(),
+    })),
+    skill_evidence: z
+        .object({
+        required_skill_ids: z.array(z.string()),
+        evidence: z.array(z.object({
+            skill_id: z.string().min(1),
+            note: z.string().min(10),
+            source: z.enum(['manual', 'tooling', 'quality_artifact']).default('manual'),
+        })),
+        verification_rule: z.string().min(1),
+    })
+        .default({
+        required_skill_ids: [],
+        evidence: [],
+        verification_rule: 'No skill evidence required for this feature.',
+    }),
+    acceptance_matrix: z.array(z.object({
+        criterion: z.string(),
+        status: z.enum(['met', 'not_met', 'na']),
+        evidence: z.string(),
+    })),
+    exceptions: z.array(z.object({
+        scope: z.string(),
+        reason: z.string(),
+        accepted_risk: z.string(),
+        compensating_control: z.string(),
+    })),
+    remediation_policy: z.object({
+        on_coverage_miss: z.enum(['re_task', 'exception', 'block']),
+        max_rounds: z.number().default(3),
+    }),
+    traceability: workspaceTraceabilitySchema.default({
+        spec_anchor: {
+            spec_updated_at: '',
+            changelog_refs: [],
+        },
+        requirements: [],
+    }),
+    security_integrity: z
+        .object({
+        endpoint_auth_review: z.enum(['not_applicable', 'pending', 'passed', 'failed']).default('pending'),
+        sensitive_data_exposure_review: z
+            .enum(['not_applicable', 'pending', 'passed', 'failed'])
+            .default('pending'),
+        incident_response_review: z.enum(['not_applicable', 'pending', 'passed', 'failed']).default('pending'),
+        notes: z.string().optional(),
+    })
+        .optional(),
+});
+export const workspaceDocumentSchemas = {
+    '1-spec.yaml': workspaceSpecSchema,
+    '2-plan.yaml': workspacePlanSchema,
+    '3-tasks.yaml': workspaceTasksSchema,
+    '4-changelog.yaml': workspaceChangelogSchema,
+    '5-quality.yaml': workspaceQualitySchema,
+};
+export class WorkspaceYamlError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'WorkspaceYamlError';
+    }
+}
+export function workspaceSchemaForFile(fileName) {
+    return workspaceDocumentSchemas[fileName];
+}
+export function parseWorkspaceYamlDocument(fileName, content) {
+    const schema = workspaceSchemaForFile(fileName);
+    if (!schema) {
+        throw new WorkspaceYamlError(`Workspace schema not found for ${fileName}.`);
+    }
+    let parsed;
+    try {
+        parsed = parseYaml(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new WorkspaceYamlError(`Workspace YAML parse failed for ${fileName}: ${message}`);
+    }
+    const result = schema.safeParse(parsed);
+    if (!result.success) {
+        throw new WorkspaceYamlError(`Workspace YAML schema validation failed for ${fileName}: ${result.error.message}`);
+    }
+    return result.data;
+}
+export function stringifyWorkspaceYamlDocument(fileName, value) {
+    const schema = workspaceSchemaForFile(fileName);
+    if (!schema) {
+        throw new WorkspaceYamlError(`Workspace schema not found for ${fileName}.`);
+    }
+    const schemaValidation = schema.safeParse(value);
+    if (!schemaValidation.success) {
+        throw new WorkspaceYamlError(`Workspace YAML schema validation failed before serialization for ${fileName}: ${schemaValidation.error.message}`);
+    }
+    const serialized = stringifyYaml(schemaValidation.data, {
+        lineWidth: 0,
+    });
+    parseWorkspaceYamlDocument(fileName, serialized);
+    return serialized;
+}
+//# sourceMappingURL=workspace-schemas.js.map

package/dist/core/sdd/write-manifest.d.ts

@@ -0,0 +1,25 @@
+export type WriteOperation = {
+    type: 'write';
+    relativePath: string;
+    content: string;
+} | {
+    type: 'mkdir';
+    relativePath: string;
+} | {
+    type: 'delete';
+    relativePath: string;
+};
+export interface SddWriteCommitOptions {
+    bypassPolicy?: boolean;
+}
+export declare class SddWritePolicyError extends Error {
+    constructor(message: string);
+}
+export declare class SddWriteTransaction {
+    private operations;
+    writeFile(relativePath: string, content: string): void;
+    mkdir(relativePath: string): void;
+    delete(relativePath: string): void;
+    commit(projectRoot: string, memoryRoot: string, label?: string, options?: SddWriteCommitOptions): Promise<void>;
+}
+//# sourceMappingURL=write-manifest.d.ts.map

package/dist/core/sdd/write-manifest.js

@@ -0,0 +1,353 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { RootResolver } from './root-resolver.js';
+import { loadProjectSddConfig, resolveSddPaths } from './state.js';
+import { parseWorkspaceYamlDocument, workspaceSchemaForFile } from './workspace-schemas.js';
+export class SddWritePolicyError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SddWritePolicyError';
+    }
+}
+const FEATURE_DIR_PATTERN = /^FEAT-\d{4}$/;
+const CANONICAL_FEATURE_FILES = new Set([
+    '1-spec.yaml',
+    '2-plan.yaml',
+    '3-tasks.yaml',
+    '4-changelog.yaml',
+    '5-quality.yaml',
+]);
+const DISCOVERY_DIRS = new Set(['1-insights', '2-debates', '3-epic', '4-discarded']);
+const ROOT_FILE_ALLOWLIST = new Set(['README.md', 'AGENT.md', 'config.yaml']);
+const STATIC_ROOTS = new Set(['state', 'core', 'reports', 'prompts']);
+export class SddWriteTransaction {
+    operations = [];
+    writeFile(relativePath, content) {
+        this.operations.push({ type: 'write', relativePath, content });
+    }
+    mkdir(relativePath) {
+        this.operations.push({ type: 'mkdir', relativePath });
+    }
+    delete(relativePath) {
+        this.operations.push({ type: 'delete', relativePath });
+    }
+    async commit(projectRoot, memoryRoot, label = 'SddWriteTransaction', options = {}) {
+        const verifiedOperations = [];
+        for (const op of this.operations) {
+            const targetPath = await RootResolver.verifyRealpathContainment(projectRoot, memoryRoot, op.relativePath, `${label} (${op.type})`);
+            const policyPath = path.relative(memoryRoot, targetPath).split(path.sep).join(path.posix.sep);
+            verifiedOperations.push({ operation: op, targetPath, policyPath });
+        }
+        if (options.bypassPolicy) {
+            console.warn(`[sdd:write-policy] ${label} bypassed write policy validation.`);
+        }
+        else {
+            const policyPaths = new Set(verifiedOperations.map(({ policyPath }) => policyPath.replace(/^\.\/+/, '')));
+            const config = await loadProjectSddConfig(projectRoot);
+            const paths = resolveSddPaths(projectRoot, config);
+            const stateFiles = new Set(Object.values(paths.stateFiles).map((filePath) => path.basename(filePath)));
+            const context = {
+                memoryRoot,
+                policyPaths,
+                lifecycleDirs: new Set([config.folders.planned, config.folders.active, config.folders.archived]),
+                lifecycleRoots: {
+                    planned: config.folders.planned,
+                    active: config.folders.active,
+                    archived: config.folders.archived,
+                },
+                discoveryRoot: config.folders.discovery,
+                planningRoot: config.folders.planning,
+                templatesRoot: config.folders.templates,
+                skillsRoot: config.folders.skills,
+                sourcesRoot: config.folders.deposito,
+                stateFiles,
+            };
+            for (const { operation, policyPath } of verifiedOperations) {
+                await validateWritePolicy(operation, policyPath, label, context);
+            }
+        }
+        for (const { operation, targetPath } of verifiedOperations) {
+            switch (operation.type) {
+                case 'write':
+                    await fs.mkdir(path.dirname(targetPath), { recursive: true });
+                    await fs.writeFile(targetPath, operation.content, 'utf-8');
+                    break;
+                case 'mkdir':
+                    await fs.mkdir(targetPath, { recursive: true });
+                    break;
+                case 'delete':
+                    await fs.unlink(targetPath).catch((err) => {
+                        if (err.code !== 'ENOENT')
+                            throw err;
+                    });
+                    break;
+            }
+        }
+    }
+}
+async function validateWritePolicy(operation, policyPath, label, context) {
+    const normalizedPath = policyPath.replace(/^\.\/+/, '');
+    if (!normalizedPath || normalizedPath === '.') {
+        return;
+    }
+    const segments = normalizedPath.split('/').filter(Boolean);
+    const [topLevel] = segments;
+    if (segments.length === 1 && ROOT_FILE_ALLOWLIST.has(topLevel)) {
+        if (operation.type === 'mkdir') {
+            throw policyError(label, operation, policyPath, 'root-level files cannot be created as directories');
+        }
+        return;
+    }
+    if (context.lifecycleDirs.has(topLevel)) {
+        await validateLifecyclePath(operation, normalizedPath, segments, label, context);
+        return;
+    }
+    if (topLevel === 'state') {
+        validateStatePath(operation, normalizedPath, segments, label, context);
+        return;
+    }
+    if (topLevel === context.discoveryRoot) {
+        validateDiscoveryPath(operation, normalizedPath, segments, label);
+        return;
+    }
+    if (topLevel === 'core') {
+        validateCorePath(operation, normalizedPath, segments, label);
+        return;
+    }
+    if (topLevel === context.planningRoot) {
+        validatePlanningPath(operation, normalizedPath, segments, label);
+        return;
+    }
+    if (topLevel === context.templatesRoot) {
+        validateTemplatesPath(operation, normalizedPath, segments, label);
+        return;
+    }
+    if (topLevel === context.skillsRoot) {
+        validateSkillsPath(operation, normalizedPath, segments, label);
+        return;
+    }
+    if (topLevel === 'reports') {
+        validateReportsPath(operation, normalizedPath, segments, label);
+        return;
+    }
+    if (topLevel === 'prompts') {
+        validatePromptsPath(operation, normalizedPath, segments, label);
+        return;
+    }
+    if (topLevel === context.sourcesRoot) {
+        validateSourcesPath(operation, normalizedPath, segments, label);
+        return;
+    }
+    if (STATIC_ROOTS.has(topLevel)) {
+        throw policyError(label, operation, policyPath, `path under ${topLevel} is not allowed by canonical rules`);
+    }
+    throw policyError(label, operation, policyPath, `unknown top-level path "${topLevel}" under .sdd`);
+}
+async function pathExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function hasPlannedFeatureInPolicySet(policyPaths, featureId, plannedFolder) {
+    const plannedRoot = `${plannedFolder}/${featureId}`;
+    for (const policyPath of policyPaths) {
+        if (policyPath === plannedRoot || policyPath.startsWith(`${plannedRoot}/`)) {
+            return true;
+        }
+    }
+    return false;
+}
+async function validateLifecyclePath(operation, policyPath, segments, label, context) {
+    const lifecycleRoot = segments[0];
+    const { planned, active, archived } = context.lifecycleRoots;
+    if (segments.length === 1) {
+        if (operation.type === 'mkdir') {
+            if (lifecycleRoot === archived) {
+                throw policyError(label, operation, policyPath, 'direct archived creation is forbidden');
+            }
+            return;
+        }
+        throw policyError(label, operation, policyPath, 'lifecycle roots may only be created as directories');
+    }
+    const featureId = segments[1];
+    if (!FEATURE_DIR_PATTERN.test(featureId)) {
+        throw policyError(label, operation, policyPath, 'lifecycle directories must use FEAT-NNNN feature folders');
+    }
+    if (lifecycleRoot === archived && (operation.type === 'write' || operation.type === 'mkdir')) {
+        throw policyError(label, operation, policyPath, 'direct archived creation is forbidden');
+    }
+    if (lifecycleRoot === active && (operation.type === 'write' || operation.type === 'mkdir')) {
+        const activeFeatureDir = path.join(context.memoryRoot, active, featureId);
+        const hasActiveWorkspace = await pathExists(activeFeatureDir);
+        if (!hasActiveWorkspace) {
+            const plannedFeatureDir = path.join(context.memoryRoot, planned, featureId);
+            const hasPlannedWorkspace = await pathExists(plannedFeatureDir);
+            const hasPlannedInTransaction = hasPlannedFeatureInPolicySet(context.policyPaths, featureId, planned);
+            if (!hasPlannedWorkspace && !hasPlannedInTransaction) {
+                throw policyError(label, operation, policyPath, 'active workspace creation requires planned workspace first (or bypass mode)');
+            }
+        }
+    }
+    if (segments.length === 2) {
+        if (operation.type === 'mkdir') {
+            return;
+        }
+        throw policyError(label, operation, policyPath, 'lifecycle operations must target a canonical feature file');
+    }
+    if (segments.length !== 3) {
+        throw policyError(label, operation, policyPath, 'lifecycle feature folders cannot contain nested paths');
+    }
+    const fileName = segments[2];
+    if (!CANONICAL_FEATURE_FILES.has(fileName)) {
+        throw policyError(label, operation, policyPath, 'lifecycle feature files must use canonical YAML names');
+    }
+    if ((segments[0] === planned || segments[0] === active) && operation.type === 'write') {
+        validateWorkspaceYamlContent(operation.content, fileName, label, operation, policyPath);
+    }
+}
+function validateStatePath(operation, policyPath, segments, label, context) {
+    if (segments.length === 1) {
+        if (operation.type === 'mkdir') {
+            return;
+        }
+        throw policyError(label, operation, policyPath, 'state root may only be created as a directory');
+    }
+    if (segments.length !== 2 || !context.stateFiles.has(segments[1])) {
+        throw policyError(label, operation, policyPath, 'state writes are limited to canonical state files');
+    }
+}
+function validateDiscoveryPath(operation, policyPath, segments, label) {
+    if (segments.length === 1) {
+        if (operation.type === 'mkdir') {
+            return;
+        }
+        throw policyError(label, operation, policyPath, 'discovery root may only be created as a directory');
+    }
+    const discoveryDir = segments[1];
+    if (!DISCOVERY_DIRS.has(discoveryDir)) {
+        throw policyError(label, operation, policyPath, 'discovery writes are limited to canonical discovery directories');
+    }
+    if (segments.length === 2) {
+        if (operation.type === 'mkdir') {
+            return;
+        }
+        throw policyError(label, operation, policyPath, 'discovery operations must target a markdown file');
+    }
+    if (segments.length !== 3 || !segments[2].endsWith('.md')) {
+        throw policyError(label, operation, policyPath, 'discovery files must be markdown files directly under a canonical directory');
+    }
+}
+function validateCorePath(operation, policyPath, segments, label) {
+    if (segments.length === 1) {
+        if (operation.type === 'mkdir')
+            return;
+        throw policyError(label, operation, policyPath, 'core root may only be created as a directory');
+    }
+    if (segments.length === 2) {
+        if (segments[1].endsWith('.md') && operation.type !== 'mkdir')
+            return;
+        if (operation.type === 'mkdir' && ['adrs', 'dados', 'integracoes'].includes(segments[1]))
+            return;
+        throw policyError(label, operation, policyPath, 'core accepts canonical markdown files or canonical subdirectories');
+    }
+    if (segments[1] === 'adrs' && segments.length === 3 && segments[2].endsWith('.md') && operation.type !== 'mkdir') {
+        return;
+    }
+    throw policyError(label, operation, policyPath, 'nested core writes are restricted to core/adrs/*.md');
+}
+function validatePlanningPath(operation, policyPath, segments, label) {
+    if (segments.length === 1) {
+        if (operation.type === 'mkdir')
+            return;
+        throw policyError(label, operation, policyPath, 'planning root may only be created as a directory');
+    }
+    if (segments.length === 2 && segments[1].endsWith('.md') && operation.type !== 'mkdir') {
+        return;
+    }
+    throw policyError(label, operation, policyPath, 'planning accepts markdown files directly under root');
+}
+function validateTemplatesPath(operation, policyPath, segments, label) {
+    if (segments.length === 1) {
+        if (operation.type === 'mkdir')
+            return;
+        throw policyError(label, operation, policyPath, 'templates root may only be created as a directory');
+    }
+    if (segments.length === 2 && /\.(md|ya?ml)$/.test(segments[1]) && operation.type !== 'mkdir') {
+        return;
+    }
+    throw policyError(label, operation, policyPath, 'templates accepts .md/.yaml files directly under root');
+}
+function validateSkillsPath(operation, policyPath, segments, label) {
+    if (segments.length === 1) {
+        if (operation.type === 'mkdir')
+            return;
+        throw policyError(label, operation, policyPath, 'skills root may only be created as a directory');
+    }
+    if (operation.type === 'mkdir') {
+        return;
+    }
+    if (segments.length >= 3) {
+        return;
+    }
+    throw policyError(label, operation, policyPath, 'skills writes require scoped subdirectories (e.g., curated/<id>/...)');
+}
+function validateReportsPath(operation, policyPath, segments, label) {
+    if (segments.length === 1) {
+        if (operation.type === 'mkdir')
+            return;
+        throw policyError(label, operation, policyPath, 'reports root may only be created as a directory');
+    }
+    if (operation.type === 'mkdir') {
+        return;
+    }
+    if (segments.length >= 2 && /\.(json|jsonl|md)$/.test(segments[segments.length - 1])) {
+        return;
+    }
+    throw policyError(label, operation, policyPath, 'reports accepts json/jsonl/markdown artifacts');
+}
+function validatePromptsPath(operation, policyPath, segments, label) {
+    if (segments.length === 1) {
+        if (operation.type === 'mkdir')
+            return;
+        throw policyError(label, operation, policyPath, 'prompts root may only be created as a directory');
+    }
+    if (segments.length === 2 && segments[1].endsWith('.md') && operation.type !== 'mkdir') {
+        return;
+    }
+    throw policyError(label, operation, policyPath, 'prompts accepts markdown files directly under root');
+}
+function validateSourcesPath(operation, policyPath, segments, label) {
+    if (segments.length === 1) {
+        if (operation.type === 'mkdir')
+            return;
+        throw policyError(label, operation, policyPath, 'sources root may only be created as a directory');
+    }
+    if (operation.type === 'mkdir') {
+        return;
+    }
+    if (segments.length >= 3) {
+        return;
+    }
+    throw policyError(label, operation, policyPath, 'sources writes must target a typed subdirectory');
+}
+function policyError(label, operation, policyPath, reason) {
+    return new SddWritePolicyError(`${label} (${operation.type}) violates SDD write policy for ${policyPath}: ${reason}`);
+}
+function validateWorkspaceYamlContent(content, fileName, label, operation, policyPath) {
+    const schema = workspaceSchemaForFile(fileName);
+    if (!schema) {
+        return;
+    }
+    try {
+        parseWorkspaceYamlDocument(fileName, content);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw policyError(label, operation, policyPath, `workspace YAML schema validation failed: ${message}`);
+    }
+}
+//# sourceMappingURL=write-manifest.js.map

package/dist/core/shared/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Shared Utilities
+ *
+ * Common code shared between init and update commands.
+ */
+export { SKILL_NAMES, type SkillName, COMMAND_IDS, type CommandId, type ToolSkillStatus, type ToolVersionStatus, getToolsWithSkillsDir, getToolSkillStatus, getToolStates, extractGeneratedByVersion, getToolVersionStatus, getConfiguredTools, getAllToolVersionStatus, } from './tool-detection.js';
+export { type SkillTemplateEntry, type CommandTemplateEntry, getSkillTemplates, getCommandTemplates, getCommandContents, generateSkillContent, } from './skill-generation.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/shared/index.js

@@ -0,0 +1,8 @@
+/**
+ * Shared Utilities
+ *
+ * Common code shared between init and update commands.
+ */
+export { SKILL_NAMES, COMMAND_IDS, getToolsWithSkillsDir, getToolSkillStatus, getToolStates, extractGeneratedByVersion, getToolVersionStatus, getConfiguredTools, getAllToolVersionStatus, } from './tool-detection.js';
+export { getSkillTemplates, getCommandTemplates, getCommandContents, generateSkillContent, } from './skill-generation.js';
+//# sourceMappingURL=index.js.map