@devtrack-solution/codesdd 1.2.2 → 1.2.4-rc3

package/dist/core/sdd/deepagents/reversa-subagents.js

@@ -0,0 +1,182 @@
+import { z } from 'zod';
+const FEATURE_REF_PATTERN = /^FEAT-\d{4}$/;
+const WINDOWS_ABSOLUTE_PATH_PATTERN = /^[A-Za-z]:[\\/]/;
+const ALL_DOMAINS = [
+    'legacy-analysis',
+    'rules',
+    'screens',
+    'data',
+    'architecture',
+    'migration',
+    'microservices',
+    'specs',
+    'equivalence-validation',
+];
+const DOMAIN_ROUTE_MAP = {
+    'legacy-analysis': {
+        subagent_id: 'sdd-reverse-orchestrator',
+        evidence_slug: 'legacy-analysis',
+    },
+    rules: {
+        subagent_id: 'sdd-reverse-business-rules-detective',
+        evidence_slug: 'rules',
+    },
+    screens: {
+        subagent_id: 'sdd-reverse-surface-scout',
+        evidence_slug: 'screens',
+    },
+    data: {
+        subagent_id: 'sdd-reverse-domain-essence-extractor',
+        evidence_slug: 'data',
+    },
+    architecture: {
+        subagent_id: 'sdd-reverse-module-archaeologist',
+        evidence_slug: 'architecture',
+    },
+    migration: {
+        subagent_id: 'sdd-reverse-migration-planner',
+        evidence_slug: 'migration',
+    },
+    microservices: {
+        subagent_id: 'sdd-reverse-forward-planner',
+        evidence_slug: 'microservices',
+    },
+    specs: {
+        subagent_id: 'sdd-reverse-spec-writer',
+        evidence_slug: 'specs',
+    },
+    'equivalence-validation': {
+        subagent_id: 'sdd-reverse-reconstructor',
+        evidence_slug: 'equivalence-validation',
+    },
+};
+export const reversaDomainSchema = z.enum(ALL_DOMAINS);
+export const deepAgentsReversaRequestSchema = z.object({
+    feature_ref: z.string().regex(FEATURE_REF_PATTERN),
+    domains: z.array(reversaDomainSchema).default([...ALL_DOMAINS]),
+    legacy_sources: z.array(z.string().min(1)).default([]),
+});
+const reversaRouteSchema = z.object({
+    domain: reversaDomainSchema,
+    subagent_id: z.string().min(1),
+    skill_ref: z.string().min(1),
+    legacy_input_refs: z.array(z.string().min(1)).default([]),
+    evidence_refs: z.array(z.string().min(1)).default([]),
+    quality_refs: z.array(z.string().min(1)).default([]),
+});
+export const deepAgentsReversaPlanSchema = z.object({
+    schema_version: z.literal(1),
+    feature_ref: z.string().regex(FEATURE_REF_PATTERN),
+    runtime_provider: z.literal('deepagents'),
+    status: z.enum(['ready', 'blocked']),
+    fail_closed: z.literal(true),
+    reasons: z.array(z.string()).default([]),
+    canonical_authority: z.object({
+        governance_system: z.literal('CodeSDD'),
+        canonical_state_path: z.literal('.sdd/state/**'),
+        direct_state_mutation_allowed: z.literal(false),
+    }),
+    legacy_input_policy: z.object({
+        trust_model: z.literal('untrusted'),
+        source_attestation_required: z.literal(true),
+        accepted_sources: z.array(z.string().min(1)).default([]),
+        rejected_sources: z
+            .array(z.object({
+            path: z.string().min(1),
+            reason: z.string().min(1),
+        }))
+            .default([]),
+    }),
+    routes: z.array(reversaRouteSchema).default([]),
+});
+export function planDeepAgentsReversaSubagents(request) {
+    const parsed = deepAgentsReversaRequestSchema.parse(request);
+    const acceptedSources = [];
+    const rejectedSources = [];
+    for (const source of parsed.legacy_sources) {
+        const normalized = normalizeRelativePath(source);
+        if (!normalized) {
+            rejectedSources.push({
+                path: source,
+                reason: 'Source path is not a safe project-relative path.',
+            });
+            continue;
+        }
+        if (isCanonicalStatePath(normalized)) {
+            rejectedSources.push({
+                path: source,
+                reason: 'Legacy source path cannot target canonical state files under .sdd/state/.',
+            });
+            continue;
+        }
+        acceptedSources.push(normalized);
+    }
+    const reasons = rejectedSources.map((entry) => `${entry.path}: ${entry.reason}`);
+    const domains = uniqueDomains(parsed.domains);
+    const routes = reasons.length > 0
+        ? []
+        : domains.map((domain) => buildRoute(parsed.feature_ref, domain, acceptedSources));
+    return deepAgentsReversaPlanSchema.parse({
+        schema_version: 1,
+        feature_ref: parsed.feature_ref,
+        runtime_provider: 'deepagents',
+        status: reasons.length === 0 ? 'ready' : 'blocked',
+        fail_closed: true,
+        reasons,
+        canonical_authority: {
+            governance_system: 'CodeSDD',
+            canonical_state_path: '.sdd/state/**',
+            direct_state_mutation_allowed: false,
+        },
+        legacy_input_policy: {
+            trust_model: 'untrusted',
+            source_attestation_required: true,
+            accepted_sources: acceptedSources,
+            rejected_sources: rejectedSources,
+        },
+        routes,
+    });
+}
+function buildRoute(featureRef, domain, acceptedSources) {
+    const config = DOMAIN_ROUTE_MAP[domain];
+    const evidenceRoot = `.sdd/evidence/reversa/${featureRef}`;
+    return {
+        domain,
+        subagent_id: config.subagent_id,
+        skill_ref: `.sdd/skills/curated/${config.subagent_id}/SKILL.md`,
+        legacy_input_refs: acceptedSources,
+        evidence_refs: [
+            `${evidenceRoot}/legacy-input-attestation.yaml`,
+            `${evidenceRoot}/${config.evidence_slug}.yaml`,
+        ],
+        quality_refs: [
+            `.sdd/active/${featureRef}/5-quality.yaml#requirement_validation_evidence_risk_matrix`,
+        ],
+    };
+}
+function uniqueDomains(domains) {
+    const seen = new Set();
+    const unique = [];
+    for (const domain of domains) {
+        if (!seen.has(domain)) {
+            seen.add(domain);
+            unique.push(domain);
+        }
+    }
+    return unique;
+}
+function normalizeRelativePath(value) {
+    const normalized = value.replace(/\\/gu, '/').replace(/^\.\//u, '');
+    if (!normalized || normalized === '.' || normalized.startsWith('/') || WINDOWS_ABSOLUTE_PATH_PATTERN.test(normalized)) {
+        return null;
+    }
+    const segments = normalized.split('/').filter(Boolean);
+    if (segments.some((segment) => segment === '..')) {
+        return null;
+    }
+    return segments.join('/');
+}
+function isCanonicalStatePath(value) {
+    return value === '.sdd/state' || value.startsWith('.sdd/state/');
+}
+//# sourceMappingURL=reversa-subagents.js.map

package/dist/core/sdd/deepagents/runtime-factory.d.ts

@@ -0,0 +1,90 @@
+import type { CreateDeepAgentParams } from 'deepagents';
+import type { DeepAgentsExecutionMode, DeepAgentsTrustTier } from './backend.js';
+import { type DeepAgentsOpenAiImporter } from './model-provider.js';
+import { type DeepAgentsOperation, type DeepAgentsPolicySnapshot, type DeepAgentsRuntimeMode, type DeepAgentsRuntimeReadiness } from './policy.js';
+import { type DeepAgentsRuntimePolicyDecision } from './policy-enforcement.js';
+import { type DeepAgentsRuntimeImporter, type DeepAgentsRuntimeLoadResult } from './runtime-loader.js';
+export type DeepAgentsRuntimeAdapterStatus = 'disabled' | 'ready' | 'blocked';
+export type DeepAgentsAgent = {
+    invoke(input: unknown, config?: unknown): Promise<unknown>;
+};
+export type DeepAgentsAgentConfig = CreateDeepAgentParams;
+export type DeepAgentsInterruptConfig = NonNullable<CreateDeepAgentParams['interruptOn']>;
+export interface DeepAgentsRuntimeFactoryRequest {
+    featureRef: string;
+    objective: string;
+    mode?: DeepAgentsExecutionMode;
+    name?: string;
+    runId?: string;
+    systemPrompt?: string;
+    tools?: DeepAgentsAgentConfig['tools'];
+    subagents?: DeepAgentsAgentConfig['subagents'];
+    skills?: string[];
+    backend?: DeepAgentsAgentConfig['backend'];
+    interruptOn?: DeepAgentsAgentConfig['interruptOn'];
+    expectedEvidence?: string[];
+    projectRoot?: string;
+    trustTier?: DeepAgentsTrustTier;
+    writeScope?: string[];
+    plannedWrites?: string[];
+    requestedEnv?: string[];
+    networkDomains?: string[];
+    operations?: DeepAgentsOperation[];
+    approvalGrants?: string[];
+}
+export interface NormalizedDeepAgentsRuntimeRequest {
+    featureRef: string;
+    objective: string;
+    mode: DeepAgentsExecutionMode;
+    name: string;
+    runId: string;
+    systemPrompt: string;
+    tools: DeepAgentsAgentConfig['tools'];
+    subagents: DeepAgentsAgentConfig['subagents'];
+    skills: string[];
+    backend?: DeepAgentsAgentConfig['backend'];
+    interruptOn: DeepAgentsInterruptConfig;
+    expectedEvidence: string[];
+}
+export interface DeepAgentsRuntimeFactoryOptions {
+    snapshot?: DeepAgentsPolicySnapshot;
+    env?: NodeJS.ProcessEnv;
+    importer?: DeepAgentsRuntimeImporter;
+    modelProviderImporter?: DeepAgentsOpenAiImporter;
+}
+export interface DeepAgentsRuntimeAdapterEnvelope {
+    schema_version: 1;
+    contract: 'deepagents-runtime-adapter/v1';
+    runtime: DeepAgentsRuntimeMode;
+    status: DeepAgentsRuntimeAdapterStatus;
+    feature_ref: string;
+    mode: DeepAgentsExecutionMode;
+    run_id: string;
+    fail_closed: true;
+    can_instantiate_agent: boolean;
+    config_fingerprint: string;
+    readiness: DeepAgentsRuntimeReadiness;
+    policy: DeepAgentsRuntimePolicyDecision;
+    reasons: string[];
+    expected_evidence: string[];
+}
+export interface DeepAgentsRuntimeAdapter {
+    readonly runtime: DeepAgentsRuntimeMode;
+    readonly status: DeepAgentsRuntimeAdapterStatus;
+    readonly request: NormalizedDeepAgentsRuntimeRequest;
+    readonly snapshot: DeepAgentsPolicySnapshot;
+    readonly loadResult: DeepAgentsRuntimeLoadResult;
+    readonly policyDecision: DeepAgentsRuntimePolicyDecision;
+    readonly reasons: string[];
+    readonly canInstantiateAgent: boolean;
+    createAgentConfig(): DeepAgentsAgentConfig | null;
+    createAgent(): Promise<DeepAgentsAgent>;
+    describe(): DeepAgentsRuntimeAdapterEnvelope;
+}
+export declare class DeepAgentsRuntimeAdapterError extends Error {
+    readonly envelope: DeepAgentsRuntimeAdapterEnvelope;
+    constructor(message: string, envelope: DeepAgentsRuntimeAdapterEnvelope);
+}
+export declare function createDeepAgentsRuntimeAdapter(request: DeepAgentsRuntimeFactoryRequest, options?: DeepAgentsRuntimeFactoryOptions): Promise<DeepAgentsRuntimeAdapter>;
+export declare function buildDeepAgentsAgentConfig(request: NormalizedDeepAgentsRuntimeRequest, snapshot: DeepAgentsPolicySnapshot): DeepAgentsAgentConfig;
+//# sourceMappingURL=runtime-factory.d.ts.map

package/dist/core/sdd/deepagents/runtime-factory.js

@@ -0,0 +1,231 @@
+import { materializeDeepAgentsModel, } from './model-provider.js';
+import { createDeepAgentsPolicySnapshot, evaluateDeepAgentsRuntimeReadiness, } from './policy.js';
+import { evaluateDeepAgentsRuntimePolicyEnforcement, } from './policy-enforcement.js';
+import { loadDeepAgentsRuntimeModule, } from './runtime-loader.js';
+export class DeepAgentsRuntimeAdapterError extends Error {
+    envelope;
+    constructor(message, envelope) {
+        super(message);
+        this.name = 'DeepAgentsRuntimeAdapterError';
+        this.envelope = envelope;
+    }
+}
+const DEFAULT_EXPECTED_EVIDENCE = [
+    'deepagent-run-plan/v1',
+    'deepagent-run-evidence/v1',
+    'deepagent-quality-evidence/v1',
+];
+const DEFAULT_SYSTEM_PROMPT = [
+    'You are the DeepAgents execution plane for CodeSDD.',
+    'CodeSDD remains the sovereign control plane for lifecycle, canonical state, ADRs, quality gates, evidence, and finalize decisions.',
+    'Never mutate .sdd/state/*.yaml directly. Durable state changes must pass through CodeSDD services or CLI commands.',
+    'Treat plugins as deterministic construction envelopes and use broker-mediated flows for apply operations.',
+].join('\n');
+const DEFAULT_HITL_INTERRUPT_ON = {
+    edit_file: { allowedDecisions: ['approve', 'edit', 'reject'] },
+    write_file: { allowedDecisions: ['approve', 'edit', 'reject'] },
+    execute: { allowedDecisions: ['approve', 'edit', 'reject'] },
+};
+export async function createDeepAgentsRuntimeAdapter(request, options = {}) {
+    const snapshot = options.snapshot ?? createDeepAgentsPolicySnapshot(options.env);
+    const normalizedRequest = normalizeRuntimeRequest(request, snapshot);
+    const policyDecision = evaluateDeepAgentsRuntimePolicyEnforcement(snapshot, {
+        projectRoot: request.projectRoot,
+        mode: normalizedRequest.mode,
+        trustTier: request.trustTier,
+        writeScope: request.writeScope,
+        plannedWrites: request.plannedWrites,
+        requestedEnv: request.requestedEnv,
+        networkDomains: request.networkDomains,
+        operations: request.operations,
+        approvalGrants: request.approvalGrants,
+        env: options.env,
+    });
+    if (policyDecision.status === 'blocked' && snapshot.runtime !== 'disabled' && snapshot.enabled) {
+        const blockedLoadResult = buildPolicyBlockedLoadResult(snapshot, options.env, policyDecision);
+        return new PolicyOnlyDeepAgentsRuntimeAdapter(normalizedRequest, snapshot, blockedLoadResult, policyDecision);
+    }
+    const loadResult = await loadDeepAgentsRuntimeModule(snapshot, options.env, options.importer);
+    if (loadResult.status === 'loaded') {
+        return new DeepAgentsJsRuntimeAdapter(normalizedRequest, snapshot, loadResult, policyDecision, options.env, options.modelProviderImporter);
+    }
+    if (loadResult.status === 'fake') {
+        return new FakeDeepAgentsRuntimeAdapter(normalizedRequest, snapshot, loadResult, policyDecision, options.env);
+    }
+    return new PolicyOnlyDeepAgentsRuntimeAdapter(normalizedRequest, snapshot, loadResult, policyDecision, options.env);
+}
+export function buildDeepAgentsAgentConfig(request, snapshot) {
+    const config = {
+        name: request.name,
+        model: snapshot.model,
+        systemPrompt: request.systemPrompt,
+        interruptOn: request.interruptOn,
+    };
+    if (request.tools && request.tools.length > 0) {
+        config.tools = request.tools;
+    }
+    if (request.subagents && request.subagents.length > 0) {
+        config.subagents = request.subagents;
+    }
+    if (request.skills.length > 0) {
+        config.skills = request.skills;
+    }
+    if (request.backend) {
+        config.backend = request.backend;
+    }
+    return config;
+}
+function normalizeRuntimeRequest(request, snapshot) {
+    const featureRef = request.featureRef.trim().toUpperCase();
+    const mode = request.mode ?? snapshot.defaultMode;
+    const name = (request.name || `codesdd-${featureRef.toLowerCase()}-deepagent`).trim();
+    const runId = (request.runId || `deepagents-${featureRef}-${mode}-${snapshot.configFingerprint.slice(0, 12)}`).trim();
+    const promptParts = [
+        DEFAULT_SYSTEM_PROMPT,
+        `Feature: ${featureRef}`,
+        `Execution mode: ${mode}`,
+        `Objective: ${request.objective.trim()}`,
+    ];
+    if (request.systemPrompt?.trim()) {
+        promptParts.push(request.systemPrompt.trim());
+    }
+    return {
+        featureRef,
+        objective: request.objective.trim(),
+        mode,
+        name,
+        runId,
+        systemPrompt: promptParts.join('\n\n'),
+        tools: request.tools ?? [],
+        subagents: request.subagents ?? [],
+        skills: request.skills ?? [],
+        backend: request.backend,
+        interruptOn: request.interruptOn ?? DEFAULT_HITL_INTERRUPT_ON,
+        expectedEvidence: request.expectedEvidence ?? DEFAULT_EXPECTED_EVIDENCE,
+    };
+}
+class BaseDeepAgentsRuntimeAdapter {
+    request;
+    snapshot;
+    loadResult;
+    policyDecision;
+    env;
+    reasons;
+    constructor(request, snapshot, loadResult, policyDecision, env = process.env) {
+        this.request = request;
+        this.snapshot = snapshot;
+        this.loadResult = loadResult;
+        this.policyDecision = policyDecision;
+        this.env = env;
+        this.reasons = loadResult.reasons;
+    }
+    get runtime() {
+        return this.loadResult.runtime;
+    }
+    describe() {
+        return {
+            schema_version: 1,
+            contract: 'deepagents-runtime-adapter/v1',
+            runtime: this.runtime,
+            status: this.status,
+            feature_ref: this.request.featureRef,
+            mode: this.request.mode,
+            run_id: this.request.runId,
+            fail_closed: true,
+            can_instantiate_agent: this.canInstantiateAgent,
+            config_fingerprint: this.snapshot.configFingerprint,
+            readiness: this.loadResult.readiness,
+            policy: this.policyDecision,
+            reasons: this.reasons,
+            expected_evidence: this.request.expectedEvidence,
+        };
+    }
+    blockedAgent(message) {
+        throw new DeepAgentsRuntimeAdapterError(message, this.describe());
+    }
+}
+function buildPolicyBlockedLoadResult(snapshot, env, policyDecision) {
+    const readiness = evaluateDeepAgentsRuntimeReadiness(snapshot, env);
+    return {
+        status: 'blocked',
+        runtime: snapshot.runtime,
+        readiness,
+        moduleAvailable: false,
+        reasons: [...readiness.reasons, ...policyDecision.reasons],
+    };
+}
+class PolicyOnlyDeepAgentsRuntimeAdapter extends BaseDeepAgentsRuntimeAdapter {
+    get status() {
+        return this.loadResult.status === 'disabled' ? 'disabled' : 'blocked';
+    }
+    get canInstantiateAgent() {
+        return false;
+    }
+    createAgentConfig() {
+        return null;
+    }
+    async createAgent() {
+        return this.blockedAgent('DeepAgents runtime is not available under the current policy snapshot.');
+    }
+}
+class FakeDeepAgentsRuntimeAdapter extends BaseDeepAgentsRuntimeAdapter {
+    get status() {
+        return 'ready';
+    }
+    get canInstantiateAgent() {
+        return true;
+    }
+    createAgentConfig() {
+        return buildDeepAgentsAgentConfig(this.request, this.snapshot);
+    }
+    async createAgent() {
+        const envelope = this.describe();
+        const request = this.request;
+        return {
+            async invoke(input) {
+                return {
+                    schema_version: 1,
+                    contract: 'deepagents-fake-agent-result/v1',
+                    runtime: 'fake',
+                    status: 'completed',
+                    feature_ref: request.featureRef,
+                    mode: request.mode,
+                    run_id: request.runId,
+                    objective: request.objective,
+                    input,
+                    adapter: envelope,
+                };
+            },
+        };
+    }
+}
+class DeepAgentsJsRuntimeAdapter extends BaseDeepAgentsRuntimeAdapter {
+    modelProviderImporter;
+    constructor(request, snapshot, loadResult, policyDecision, env = process.env, modelProviderImporter) {
+        super(request, snapshot, loadResult, policyDecision, env);
+        this.modelProviderImporter = modelProviderImporter;
+    }
+    get status() {
+        return 'ready';
+    }
+    get canInstantiateAgent() {
+        return true;
+    }
+    createAgentConfig() {
+        return buildDeepAgentsAgentConfig(this.request, this.snapshot);
+    }
+    async createAgent() {
+        const module = this.loadResult.module;
+        const createDeepAgent = module?.createDeepAgent;
+        if (typeof createDeepAgent !== 'function') {
+            return this.blockedAgent('deepagents-js runtime module is loaded but createDeepAgent is not callable.');
+        }
+        const config = this.createAgentConfig();
+        const model = await materializeDeepAgentsModel(this.snapshot.model, this.env, this.modelProviderImporter);
+        return createDeepAgent({
+            ...config,
+            ...(model ? { model } : {}),
+        });
+    }
+}
+//# sourceMappingURL=runtime-factory.js.map

package/dist/core/sdd/deepagents/runtime-loader.d.ts

@@ -0,0 +1,16 @@
+import { type DeepAgentsPolicySnapshot, type DeepAgentsRuntimeMode, type DeepAgentsRuntimeReadiness } from './policy.js';
+export interface DeepAgentsRuntimeModule {
+    createDeepAgent: unknown;
+    [key: string]: unknown;
+}
+export interface DeepAgentsRuntimeLoadResult {
+    status: 'disabled' | 'fake' | 'loaded' | 'blocked';
+    runtime: DeepAgentsRuntimeMode;
+    readiness: DeepAgentsRuntimeReadiness;
+    moduleAvailable: boolean;
+    module?: DeepAgentsRuntimeModule;
+    reasons: string[];
+}
+export type DeepAgentsRuntimeImporter = () => Promise<Record<string, unknown>>;
+export declare function loadDeepAgentsRuntimeModule(snapshot?: DeepAgentsPolicySnapshot, env?: NodeJS.ProcessEnv, importer?: DeepAgentsRuntimeImporter): Promise<DeepAgentsRuntimeLoadResult>;
+//# sourceMappingURL=runtime-loader.d.ts.map

package/dist/core/sdd/deepagents/runtime-loader.js

@@ -0,0 +1,65 @@
+import { createDeepAgentsPolicySnapshot, evaluateDeepAgentsRuntimeReadiness, } from './policy.js';
+export async function loadDeepAgentsRuntimeModule(snapshot = createDeepAgentsPolicySnapshot(), env = process.env, importer = importDeepAgentsPackage) {
+    const readiness = evaluateDeepAgentsRuntimeReadiness(snapshot, env);
+    if (readiness.status === 'disabled') {
+        return {
+            status: 'disabled',
+            runtime: snapshot.runtime,
+            readiness,
+            moduleAvailable: false,
+            reasons: readiness.reasons,
+        };
+    }
+    if (snapshot.runtime === 'fake' && readiness.status === 'ready') {
+        return {
+            status: 'fake',
+            runtime: snapshot.runtime,
+            readiness,
+            moduleAvailable: false,
+            reasons: [],
+        };
+    }
+    if (readiness.status === 'blocked') {
+        return {
+            status: 'blocked',
+            runtime: snapshot.runtime,
+            readiness,
+            moduleAvailable: false,
+            reasons: readiness.reasons,
+        };
+    }
+    try {
+        const module = await importer();
+        if (typeof module.createDeepAgent !== 'function') {
+            return {
+                status: 'blocked',
+                runtime: snapshot.runtime,
+                readiness,
+                moduleAvailable: true,
+                reasons: ['deepagents package is installed but does not expose createDeepAgent.'],
+            };
+        }
+        return {
+            status: 'loaded',
+            runtime: snapshot.runtime,
+            readiness,
+            moduleAvailable: true,
+            module: module,
+            reasons: [],
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            status: 'blocked',
+            runtime: snapshot.runtime,
+            readiness,
+            moduleAvailable: false,
+            reasons: [`deepagents package could not be loaded lazily: ${message}`],
+        };
+    }
+}
+async function importDeepAgentsPackage() {
+    return import('deepagents');
+}
+//# sourceMappingURL=runtime-loader.js.map

package/dist/core/sdd/default-bootstrap-files.d.ts

@@ -10,14 +10,14 @@ export interface SddReadmeFolders {
 }
 export declare function buildSddInternalReadme(memoryDir?: string, folders?: SddReadmeFolders): string;
 export declare const PROMPTS_README_MD = "# Recommended SDD Prompts\n\nUse these prompts to speed up agent workflows without losing the SDD standard.\n\n## Recommended Order For Raw Material\n1. `00-start-here.md`\n2. `01-source-intake.md`\n3. `02-normalize-planning.md`\n4. `03-feature-execution.md`\n5. `04-finalize-consolidation.md`\n\nRule: prompts guide the agent, but the canonical state remains in `.sdd/state/*.yaml`.\nDo not persist project memory, workflow state, backlog, or handoff in external context stores.\n";
-export declare const PROMPT_00_COMECE_POR_AQUI_MD = "# Start Here (First Use)\n\nIf you have never used CodeSDD, follow this order.\n\n## 1) Install And Initialize The Project\n\nIn the terminal, from your project directory:\n\n```bash\ncodesdd install --tools none --lang en-US --layout en-US\ncodesdd sdd init --frontend --lang en-US --layout en-US\ncodesdd sdd init-context\ncodesdd sdd check --render\ncodesdd sdd rebuild --from-disk --dry-run\ncodesdd sdd dedup --apply --dry-run\ncodesdd sdd onboard system\n```\n\n## 2) Understand The Main Folders\n\n- `.sdd/sources/`: raw material such as PRDs, wireframes, stories, and references.\n- `.sdd/state/`: canonical YAML source of truth.\n- `.sdd/core/`: generated human-readable system overview.\n- `.sdd/planning/`: backlog, progress, and finalize queue.\n- `.sdd/active/`: active FEAT workspaces.\n- `.sdd/archived/`: finalized workspaces.\n\nCodeSDD is the only operational memory for the project. Do not use external context, memory, workflow, backlog, scratchpad, or handoff stores as active project state.\n\n## 3) I Have PRDs, Wireframes, Or Stories. What Now?\n\n1. Place the files under `.sdd/sources/` in the appropriate subfolders.\n2. Run:\n\n```bash\ncodesdd sdd ingest-deposito --source-dir .sdd/sources --title \"Initial system planning\"\n```\n\n3. Review:\n\n```bash\ncodesdd sdd check --render\ncodesdd sdd next\n```\n\nExpected result:\n- sources indexed in `.sdd/state/source-index.yaml`\n- EPIC created or reused\n- FEATs generated in the backlog\n- first ready FEAT started automatically when possible\n\n## 4) Execute A Feature\n\n```bash\ncodesdd sdd start FEAT-0001 --flow-mode standard\ncodesdd sdd context FEAT-0001\ncodesdd sdd frontend-impact FEAT-0001 --status required --reason \"New route and UI components\"\n```\n\nImplement and update the FEAT package:\n- `1-spec.yaml`\n- `2-plan.yaml`\n- `5-quality.yaml`\n- `3-tasks.yaml`\n- `4-changelog.yaml`\n\n## 5) Finalize Without Losing Context\n\n```bash\ncodesdd sdd finalize --ref FEAT-0001\ncodesdd sdd check --render\ncodesdd sdd onboard system\n```\n\nGolden rule:\n- A FEAT is only truly complete after documentation consolidation.\n\n## 6) Short Usage Story\n\nThe team placed a PRD and a wireframe in `.sdd/sources/`.\nThey ran `codesdd sdd ingest-deposito --source-dir .sdd/sources` and got an EPIC plus ready FEATs.\nThey started the priority FEAT with `codesdd sdd start FEAT-0001`.\nBefore coding, they ran `codesdd sdd context FEAT-0001`.\nAfter implementation, they ran `codesdd sdd finalize --ref FEAT-0001`.\nResult: backlog updated, docs synchronized, and the next FEAT released without guesswork.\n\n## 7) Essential Commands\n\n- `codesdd sdd onboard system`: understand the current state.\n- `codesdd sdd ingest-deposito --source-dir .sdd/sources`: turn raw material into an executable trail.\n- `codesdd sdd rebuild --from-disk --dry-run`: preview state reconciliation from disk artifacts.\n- `codesdd sdd audit --json`: persist an audit snapshot in `.sdd/state/audit-history.yaml`.\n- `codesdd sdd metrics --since 7d`: inspect lead time, aging, and throughput.\n- `codesdd sdd dedup --apply --dry-run`: preview historical warning_links reconciliation.\n- `codesdd sdd lint feature FEAT-0001`: inspect feature scope before execution.\n- `codesdd sdd next`: see what can start now.\n- `codesdd sdd start FEAT-0001`: open feature execution.\n- `codesdd sdd context FEAT-0001`: generate focused context.\n- `codesdd sdd frontend-impact FEAT-0001 --status required|none --reason \"...\"`: declare frontend impact.\n- `codesdd sdd finalize --ref FEAT-0001`: consolidate memory and close.\n";
+export declare const PROMPT_00_COMECE_POR_AQUI_MD = "# Start Here (First Use)\n\nIf you have never used CodeSDD, follow this order.\n\n## 1) Install And Initialize The Project\n\nIn the terminal, from your project directory:\n\n```bash\ncodesdd install --tools none --lang en-US --layout en-US\ncodesdd sdd init --frontend --lang en-US --layout en-US\ncodesdd sdd init-context --frontend --lang en-US --layout en-US\ncodesdd sdd check --render\ncodesdd sdd rebuild --from-disk --dry-run\ncodesdd sdd dedup --apply --dry-run\ncodesdd sdd onboard system\ncodesdd reload --tools none --lang en-US --layout en-US\n```\n\n## 2) Understand The Main Folders\n\n- `.sdd/sources/`: raw material such as PRDs, wireframes, stories, and references.\n- `.sdd/state/`: canonical YAML source of truth.\n- `.sdd/core/`: generated human-readable system overview.\n- `.sdd/planning/`: backlog, progress, and finalize queue.\n- `.sdd/active/`: active FEAT workspaces.\n- `.sdd/archived/`: finalized workspaces.\n\nCodeSDD is the only operational memory for the project. Do not use external context, memory, workflow, backlog, scratchpad, or handoff stores as active project state.\nIn initialized CodeSDD repositories, requests that imply implementation, edits, validation, execution, or finalize implicitly require CodeSDD planning unless explicitly marked read-only or outside CodeSDD.\n\n## 3) I Have PRDs, Wireframes, Or Stories. What Now?\n\n1. Place the files under `.sdd/sources/` in the appropriate subfolders.\n2. Run:\n\n```bash\ncodesdd sdd ingest-deposito --source-dir .sdd/sources --title \"Initial system planning\"\n```\n\n3. Review:\n\n```bash\ncodesdd sdd check --render\ncodesdd sdd next\n```\n\nExpected result:\n- sources indexed in `.sdd/state/source-index.yaml`\n- EPIC created or reused\n- FEATs generated in the backlog\n- first ready FEAT started automatically when possible\n\n## 4) Execute A Feature\n\n```bash\ncodesdd sdd start FEAT-0001 --flow-mode standard\ncodesdd sdd context FEAT-0001\ncodesdd sdd frontend-impact FEAT-0001 --status required --reason \"New route and UI components\"\n```\n\nImplement and update the FEAT package:\n- `1-spec.yaml`\n- `2-plan.yaml`\n- `5-quality.yaml`\n- `3-tasks.yaml`\n- `4-changelog.yaml`\n\n## 5) Finalize Without Losing Context\n\n```bash\ncodesdd sdd finalize --ref FEAT-0001\ncodesdd sdd check --render\ncodesdd sdd onboard system\n```\n\nGolden rule:\n- A FEAT is only truly complete after documentation consolidation.\n\n## 6) Short Usage Story\n\nThe team placed a PRD and a wireframe in `.sdd/sources/`.\nThey ran `codesdd sdd ingest-deposito --source-dir .sdd/sources` and got an EPIC plus ready FEATs.\nThey started the priority FEAT with `codesdd sdd start FEAT-0001`.\nBefore coding, they ran `codesdd sdd context FEAT-0001`.\nAfter implementation, they ran `codesdd sdd finalize --ref FEAT-0001`.\nResult: backlog updated, docs synchronized, and the next FEAT released without guesswork.\n\n## 7) Essential Commands\n\n- `codesdd sdd onboard system`: understand the current state.\n- `codesdd sdd ingest-deposito --source-dir .sdd/sources`: turn raw material into an executable trail.\n- `codesdd sdd rebuild --from-disk --dry-run`: preview state reconciliation from disk artifacts.\n- `codesdd sdd audit --json`: persist an audit snapshot in `.sdd/state/audit-history.yaml`.\n- `codesdd sdd metrics --since 7d`: inspect lead time, aging, and throughput.\n- `codesdd sdd dedup --apply --dry-run`: preview historical warning_links reconciliation.\n- `codesdd sdd lint feature FEAT-0001`: inspect feature scope before execution.\n- `codesdd sdd next`: see what can start now.\n- `codesdd sdd start FEAT-0001`: open feature execution.\n- `codesdd sdd context FEAT-0001`: generate focused context.\n- `codesdd sdd frontend-impact FEAT-0001 --status required|none --reason \"...\"`: declare frontend impact.\n- `codesdd sdd finalize --ref FEAT-0001`: consolidate memory and close.\n";
 export declare const PROMPT_01_INGESTAO_DEPOSITO_MD = "# Prompt: Source Intake\n\nUse the skills:\n- source-intake-sdd\n- business-extractor-sdd\n- frontend-extractor-sdd\n- planning-normalizer-sdd\n\nObjective:\n1. Scan `.sdd/sources/`.\n2. Update `.sdd/state/source-index.yaml`.\n3. Consolidate canonical context (`architecture`, `service-catalog`, `tech-stack`, `integration-contracts`, and frontend when enabled).\n4. Generate an executable trail (EPIC plus FEATs) with source traceability.\n\nRequired output:\n- summary of sources read;\n- IDs created or updated (EPIC/FEAT/FGAP/INS when ambiguity exists);\n- recommended next CLI commands.\n";
 export declare const PROMPT_02_NORMALIZAR_PLANEJAMENTO_MD = "# Prompt: Normalize Planning\n\nObjective:\nTurn consolidated material into an executable plan with clear dependencies.\n\nInstructions:\n1. Start from `.sdd/state/source-index.yaml` and `.sdd/core/*.md`.\n2. Propose EPICs and FEATs with clear English names.\n3. Define dependencies (`blocked_by`) and conflicts (`lock_domains`).\n4. List what can run in parallel.\n5. End with a documentation consolidation checklist per feature.\n";
-export declare const PROMPT_03_EXECUCAO_FEATURE_MD = "# Prompt: Feature Execution\n\nObjective:\nExecute a FEAT without losing traceability.\n\nInstructions:\n1. Run `codesdd sdd context FEAT-0001`.\n2. Update `.sdd/active/FEAT-0001/` (spec, plan, tasks, changelog).\n3. Implement.\n4. Update `.sdd/active/FEAT-0001/5-quality.yaml` with evidence or a formal exception; quality contracts are blocking by default.\n5. Update affected canonical docs.\n6. Declare frontend impact with `codesdd sdd frontend-impact FEAT-0001 ...`.\n7. Ensure architectural-impact FEATs have an ADR before finalize.\n8. Finish with `codesdd sdd finalize --ref FEAT-0001`.\n";
+export declare const PROMPT_03_EXECUCAO_FEATURE_MD = "# Prompt: Feature Execution\n\nObjective:\nExecute a FEAT without losing traceability.\n\nInstructions:\n1. Treat implementation, edit, validation, execution, and finalize requests as requiring CodeSDD planning unless the user explicitly marks the request as read-only or outside CodeSDD.\n2. Run `codesdd sdd next` and bind the work to the active or ready FEAT returned by CodeSDD.\n3. Run `codesdd sdd context FEAT-0001`.\n4. Update `.sdd/active/FEAT-0001/` (spec, plan, tasks, changelog).\n5. Implement.\n6. Update `.sdd/active/FEAT-0001/5-quality.yaml` with evidence or a formal exception; quality contracts are blocking by default.\n7. Update affected canonical docs.\n8. Declare frontend impact with `codesdd sdd frontend-impact FEAT-0001 ...`.\n9. Ensure architectural-impact FEATs have an ADR before finalize.\n10. Finish with `codesdd sdd finalize --ref FEAT-0001`.\n";
 export declare const PROMPT_04_CONSOLIDACAO_FINALIZE_MD = "# Prompt: Consolidation And Finalize\n\nObjective:\nClose a feature with complete operational memory.\n\nChecklist:\n1. Review the FEAT technical diff.\n2. Update central documentation (`README.md`, `.sdd/AGENT.md`, `.sdd/core/*.md`, `AGENTS.md`, `AGENT.md`).\n3. Ensure frontend gaps or decisions are recorded when applicable.\n4. Declare frontend impact with `codesdd sdd frontend-impact FEAT-0001 --status required|none --reason \"...\"`.\n5. Run `codesdd sdd check --render`.\n6. Run `codesdd sdd finalize --ref FEAT-0001` and report updated docs.\n";
 export declare const TEMPLATE_1_SPEC_MD = "schema_version: 1\nfeature_id: FEAT-0001\ntitle: Example workspace specification\norigin:\n  type: direct\n  ref: FEAT-0001\nobjective: This YAML specification records the feature objective with enough detail for agents to understand the expected implementation scope, user or system value, dependencies, and validation intent before source changes begin.\nexpected_outcome: The feature reaches a verifiable done state with its implementation, documentation, and quality evidence synchronized in CodeSDD.\nsystem_impact: The workspace keeps canonical state, generated views, and operational handoff aligned with the implementation.\nacceptance_refs:\n  - FEAT-0001\ngates:\n  proposta:\n    status: rascunho\n  planejamento:\n    status: rascunho\n  tarefas:\n    status: rascunho\ncompliance_context:\n  jurisdictions:\n    - BR-LGPD\n  data_classes:\n    - personal_data\n  source_refs:\n    - SRC-0001\n  legal_review_required: false\n  legal_review_notes: \"\"\ncreated_at: 2026-01-01T00:00:00.000Z\nupdated_at: 2026-01-01T00:00:00.000Z\n";
 export declare const TEMPLATE_2_PLAN_MD: string;
-export declare const TEMPLATE_QUALITY_MD = "schema_version: 1\nfeature_id: FEAT-0001\ncoverage_targets:\n  unit: 95\n  integration: 95\nvalidation_strategies:\n  - name: Targeted tests\n    command: pnpm test\n    expected: Tests pass for the touched scope.\nevidence_log: []\nskill_evidence:\n  required_skill_ids: []\n  evidence: []\n  verification_rule: No skill evidence required for this feature.\nacceptance_matrix:\n  - criterion: requirements\n    status: not_met\n    evidence: Add validation evidence before finalize.\nexceptions: []\nremediation_policy:\n  on_coverage_miss: block\n  max_rounds: 3\ntraceability:\n  spec_anchor:\n    spec_updated_at: \"\"\n    changelog_refs: []\n  requirements: []\nsecurity_integrity:\n  endpoint_auth_review: pending\n  sensitive_data_exposure_review: pending\n  incident_response_review: pending\n  notes: Record endpoint/data exposure evidence before finalize when privacy impact exists.\n";
+export declare const TEMPLATE_QUALITY_MD = "schema_version: 1\nfeature_id: FEAT-0001\ncoverage_targets:\n  unit: 95\n  integration: 95\nvalidation_strategies:\n  - name: Targeted tests\n    command: pnpm test\n    expected: Tests pass for the touched scope.\nevidence_log: []\nskill_evidence:\n  required_skill_ids: []\n  evidence: []\n  verification_rule: No skill evidence required for this feature.\nacceptance_matrix:\n  - criterion: requirements\n    status: not_met\n    evidence: Add validation evidence before finalize.\nexceptions: []\nremediation_policy:\n  on_coverage_miss: block\n  max_rounds: 3\ntraceability:\n  spec_anchor:\n    spec_updated_at: \"\"\n    changelog_refs: []\n  requirements: []\nq95_ledger:\n  threshold: 95\n  score: 0\n  status: pending\n  computed_at: \"\"\n  weights:\n    coverage: 30\n    traceability: 20\n    integrity: 20\n    naming: 10\n    token: 20\n  axes:\n    coverage:\n      raw_score: 0\n      weighted_score: 0\n      rationale: Computed during finalize.\n    traceability:\n      raw_score: 0\n      weighted_score: 0\n      rationale: Computed during finalize.\n    integrity:\n      raw_score: 0\n      weighted_score: 0\n      rationale: Computed during finalize.\n    naming:\n      raw_score: 0\n      weighted_score: 0\n      rationale: Computed during finalize.\n    token:\n      raw_score: 0\n      weighted_score: 0\n      rationale: Computed during finalize.\n  next_best_action: Record missing evidence to raise the lowest weighted axis.\nsecurity_integrity:\n  endpoint_auth_review: pending\n  sensitive_data_exposure_review: pending\n  incident_response_review: pending\n  notes: Record endpoint/data exposure evidence before finalize when privacy impact exists.\n";
 export declare const TEMPLATE_3_TASKS_MD: string;
 export declare const TEMPLATE_4_CHANGELOG_MD = "schema_version: 1\nfeature_id: FEAT-0001\nentries:\n  - timestamp: 2026-01-01T00:00:00.000Z\n    action: created\n    details: Workspace changelog initialized.\n";
 //# sourceMappingURL=default-bootstrap-files.d.ts.map