@devtrack-solution/codesdd 1.2.2

package/dist/core/sdd/coordination/coordination-adapters.d.ts

@@ -0,0 +1,73 @@
+import { type AcquireOptions } from '../state-lock.js';
+export interface CoordinationLockAdapter {
+    withLock<T>(scope: string, fn: () => Promise<T>, options?: AcquireOptions): Promise<T>;
+}
+export interface CoordinationCacheAdapter {
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, options?: {
+        ttlMs?: number;
+    }): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export interface CoordinationQueueAdapter<T = unknown> {
+    enqueue(topic: string, item: T): Promise<void>;
+    dequeue(topic: string): Promise<T | undefined>;
+    size(topic: string): Promise<number>;
+}
+export interface CoordinationEvent {
+    type: string;
+    payload?: unknown;
+    created_at: string;
+}
+export interface CoordinationEventBusAdapter {
+    publish(event: CoordinationEvent): Promise<void>;
+    drain(): Promise<CoordinationEvent[]>;
+}
+export interface RedisBoundaryConfig {
+    requested: boolean;
+    namespace: string;
+    url?: string;
+}
+export interface SddCoordinationAdapters {
+    mode: 'filesystem';
+    redis: RedisBoundaryConfig & {
+        status: 'disabled' | 'requested-unavailable';
+        reason: string;
+    };
+    locks: CoordinationLockAdapter;
+    cache: CoordinationCacheAdapter;
+    queues: CoordinationQueueAdapter;
+    events: CoordinationEventBusAdapter;
+}
+export declare class FileSystemLockAdapter implements CoordinationLockAdapter {
+    private readonly stateDir;
+    constructor(stateDir: string);
+    withLock<T>(_scope: string, fn: () => Promise<T>, options?: AcquireOptions): Promise<T>;
+}
+export declare class InMemoryCoordinationCache implements CoordinationCacheAdapter {
+    private readonly entries;
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, options?: {
+        ttlMs?: number;
+    }): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export declare class InMemoryCoordinationQueue<T = unknown> implements CoordinationQueueAdapter<T> {
+    private readonly topics;
+    enqueue(topic: string, item: T): Promise<void>;
+    dequeue(topic: string): Promise<T | undefined>;
+    size(topic: string): Promise<number>;
+}
+export declare class InMemoryCoordinationEventBus implements CoordinationEventBusAdapter {
+    private readonly events;
+    publish(event: CoordinationEvent): Promise<void>;
+    drain(): Promise<CoordinationEvent[]>;
+}
+export declare function resolveRedisBoundaryConfig(env?: NodeJS.ProcessEnv): RedisBoundaryConfig;
+export declare function createFilesystemFirstCoordinationAdapters(options: {
+    stateDir: string;
+    env?: NodeJS.ProcessEnv;
+}): SddCoordinationAdapters;
+//# sourceMappingURL=coordination-adapters.d.ts.map

package/dist/core/sdd/coordination/coordination-adapters.js

@@ -0,0 +1,87 @@
+import { withStateLock } from '../state-lock.js';
+export class FileSystemLockAdapter {
+    stateDir;
+    constructor(stateDir) {
+        this.stateDir = stateDir;
+    }
+    async withLock(_scope, fn, options) {
+        return withStateLock(this.stateDir, fn, options);
+    }
+}
+export class InMemoryCoordinationCache {
+    entries = new Map();
+    async get(key) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return undefined;
+        if (entry.expiresAt && Date.now() >= entry.expiresAt) {
+            this.entries.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    async set(key, value, options = {}) {
+        const expiresAt = options.ttlMs ? Date.now() + options.ttlMs : undefined;
+        this.entries.set(key, { value, expiresAt });
+    }
+    async delete(key) {
+        this.entries.delete(key);
+    }
+    async clear() {
+        this.entries.clear();
+    }
+}
+export class InMemoryCoordinationQueue {
+    topics = new Map();
+    async enqueue(topic, item) {
+        const queue = this.topics.get(topic) ?? [];
+        queue.push(item);
+        this.topics.set(topic, queue);
+    }
+    async dequeue(topic) {
+        const queue = this.topics.get(topic);
+        if (!queue || queue.length === 0)
+            return undefined;
+        return queue.shift();
+    }
+    async size(topic) {
+        return this.topics.get(topic)?.length ?? 0;
+    }
+}
+export class InMemoryCoordinationEventBus {
+    events = [];
+    async publish(event) {
+        this.events.push(event);
+    }
+    async drain() {
+        return this.events.splice(0, this.events.length);
+    }
+}
+export function resolveRedisBoundaryConfig(env = process.env) {
+    const url = env.CODESDD_REDIS_URL?.trim() || env.REDIS_URL?.trim() || undefined;
+    const requestedByFlag = env.CODESDD_REDIS_ENABLED === 'true';
+    const namespace = env.CODESDD_REDIS_NAMESPACE?.trim() || 'codesdd';
+    return {
+        requested: Boolean(url || requestedByFlag),
+        namespace,
+        url,
+    };
+}
+export function createFilesystemFirstCoordinationAdapters(options) {
+    const redis = resolveRedisBoundaryConfig(options.env);
+    return {
+        mode: 'filesystem',
+        redis: {
+            ...redis,
+            status: redis.requested ? 'requested-unavailable' : 'disabled',
+            reason: redis.requested
+                ? 'Redis adapter boundary is configured but no Redis client adapter is installed; filesystem-first defaults remain authoritative.'
+                : 'Redis is optional and disabled; filesystem-first defaults are authoritative.',
+        },
+        locks: new FileSystemLockAdapter(options.stateDir),
+        cache: new InMemoryCoordinationCache(),
+        queues: new InMemoryCoordinationQueue(),
+        events: new InMemoryCoordinationEventBus(),
+    };
+}
+//# sourceMappingURL=coordination-adapters.js.map

package/dist/core/sdd/coordination/index.d.ts

@@ -0,0 +1,2 @@
+export * from './coordination-adapters.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/sdd/coordination/index.js

@@ -0,0 +1,2 @@
+export * from './coordination-adapters.js';
+//# sourceMappingURL=index.js.map

package/dist/core/sdd/dedup.d.ts

@@ -0,0 +1,23 @@
+export interface SimilarityCandidate {
+    id: string;
+    title: string;
+    score: number;
+}
+export interface WarnAndLinkResult {
+    severity: 'none' | 'warning';
+    candidates: SimilarityCandidate[];
+    warningLinks: string[];
+}
+export interface WarnAndLinkOptions {
+    maxCandidates?: number;
+    minScore?: number;
+}
+export declare function normalizeSemanticText(value: string): string;
+export declare function extractNGrams(value: string, size: number): Set<string>;
+export declare function jaccardSimilarity(a: Set<string>, b: Set<string>): number;
+export declare function semanticSimilarity(a: string, b: string): number;
+export declare function warnAndLink(entityType: string, title: string, candidates: Array<{
+    id: string;
+    title: string;
+}>, options?: WarnAndLinkOptions): WarnAndLinkResult;
+//# sourceMappingURL=dedup.d.ts.map

package/dist/core/sdd/dedup.js

@@ -0,0 +1,62 @@
+const DEFAULT_THRESHOLDS = {
+    INS: 0.58,
+    DEB: 0.62,
+    FEAT: 0.6,
+};
+export function normalizeSemanticText(value) {
+    return value
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+export function extractNGrams(value, size) {
+    const normalized = normalizeSemanticText(value).replace(/\s/g, '');
+    if (!normalized)
+        return new Set();
+    if (normalized.length <= size)
+        return new Set([normalized]);
+    const grams = new Set();
+    for (let index = 0; index <= normalized.length - size; index += 1) {
+        grams.add(normalized.slice(index, index + size));
+    }
+    return grams;
+}
+export function jaccardSimilarity(a, b) {
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    const intersection = [...a].filter((token) => b.has(token)).length;
+    const union = new Set([...a, ...b]).size;
+    return union === 0 ? 0 : intersection / union;
+}
+export function semanticSimilarity(a, b) {
+    const normalizedA = normalizeSemanticText(a);
+    const normalizedB = normalizeSemanticText(b);
+    if (!normalizedA || !normalizedB)
+        return 0;
+    if (normalizedA === normalizedB)
+        return 1;
+    const bigrams = jaccardSimilarity(extractNGrams(normalizedA, 2), extractNGrams(normalizedB, 2));
+    const trigrams = jaccardSimilarity(extractNGrams(normalizedA, 3), extractNGrams(normalizedB, 3));
+    return Number((bigrams * 0.45 + trigrams * 0.55).toFixed(4));
+}
+export function warnAndLink(entityType, title, candidates, options) {
+    const threshold = options?.minScore ?? DEFAULT_THRESHOLDS[entityType] ?? 0.65;
+    const ranked = candidates
+        .map((candidate) => ({
+        id: candidate.id,
+        title: candidate.title,
+        score: semanticSimilarity(title, candidate.title),
+    }))
+        .filter((candidate) => candidate.score >= threshold)
+        .sort((left, right) => right.score - left.score)
+        .slice(0, options?.maxCandidates ?? 3);
+    return {
+        severity: ranked.length > 0 ? 'warning' : 'none',
+        candidates: ranked,
+        warningLinks: ranked.map((candidate) => candidate.id),
+    };
+}
+//# sourceMappingURL=dedup.js.map

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

@@ -0,0 +1,23 @@
+export interface SddReadmeFolders {
+    discovery?: string;
+    planning?: string;
+    skills?: string;
+    templates?: string;
+    active?: string;
+    archived?: string;
+    deposito?: string;
+    prompts?: string;
+}
+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_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_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_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

package/dist/core/sdd/default-bootstrap-files.js

@@ -0,0 +1,385 @@
+import { CLI_NAME } from '../branding.js';
+export function buildSddInternalReadme(memoryDir = '.sdd', folders = {}) {
+    const discovery = folders.discovery || 'discovery';
+    const planning = folders.planning || 'planning';
+    const skills = folders.skills || 'skills';
+    const templates = folders.templates || 'templates';
+    const active = folders.active || 'active';
+    const archived = folders.archived || 'archived';
+    const deposito = folders.deposito || 'sources';
+    const prompts = folders.prompts || 'prompts';
+    return `# SDD README
+
+This directory stores the project's operational memory.
+
+## Read First
+1. \`README.md\`
+2. \`${memoryDir}/AGENT.md\`
+3. \`${memoryDir}/core/index.md\`
+4. \`${memoryDir}/core/arquitetura.md\`
+5. \`${memoryDir}/core/servicos.md\`
+6. \`${memoryDir}/core/spec-tecnologica.md\`
+7. \`${memoryDir}/core/repo-map.md\`
+8. \`${memoryDir}/core/fontes.md\`
+9. \`${memoryDir}/core/frontend-sitemap.md\` (when frontend is enabled)
+10. \`${memoryDir}/core/frontend-decisions.md\` (when frontend is enabled)
+
+## How To Operate
+1. Run \`${CLI_NAME} sdd onboard system\` to understand current state.
+2. Run \`${CLI_NAME} sdd next\` to see what can start now.
+3. Run \`${CLI_NAME} sdd start <FEAT-ID>\` only when the item is not already active.
+4. Run \`${CLI_NAME} sdd context <FEAT-ID>\` before implementation.
+5. Record validation evidence in \`${active}/<FEAT-ID>/5-quality.yaml\`.
+6. Declare frontend impact with \`${CLI_NAME} sdd frontend-impact <FEAT-ID> --status required|none --reason "..."\`.
+7. Run \`${CLI_NAME} sdd finalize --ref <FEAT-ID>\` when consolidating the feature.
+
+## Main Folders
+- \`core/\`: current system overview.
+- \`${discovery}/\`: insights, debates, epics, and discarded items.
+- \`${planning}/\`: backlog, progress, gaps, and finalize queue.
+- \`${planning}/frontend-auditoria.md\`: frontend coverage audit by FEAT.
+- \`state/\`: canonical YAML source of truth.
+- \`${skills}/\`: local curation and bundles.
+- \`${templates}/\`: base templates for spec, plan, quality, tasks, and changelog.
+- \`${prompts}/\`: recommended prompts for common workflows.
+- \`${active}/\`: active FEAT workspaces.
+- \`${archived}/\`: finalized frozen workspaces.
+- \`${deposito}/\`: raw documents, PRDs, wireframes, and external references.
+
+## Operational Authority
+- \`state/*.yaml\` is the only canonical operational state for planning, dependencies, blockers, progress, quality, and handoff.
+- \`core/*.md\` and \`${planning}/*.md\` are operational views derived from canonical state.
+- External context, memory, workflow, backlog, scratchpad, or handoff stores are not authoritative.
+
+## Operational Rule
+Every completed feature must update relevant documentation before \`finalize\`.
+`;
+}
+export const PROMPTS_README_MD = `# Recommended SDD Prompts
+
+Use these prompts to speed up agent workflows without losing the SDD standard.
+
+## Recommended Order For Raw Material
+1. \`00-start-here.md\`
+2. \`01-source-intake.md\`
+3. \`02-normalize-planning.md\`
+4. \`03-feature-execution.md\`
+5. \`04-finalize-consolidation.md\`
+
+Rule: prompts guide the agent, but the canonical state remains in \`.sdd/state/*.yaml\`.
+Do not persist project memory, workflow state, backlog, or handoff in external context stores.
+`;
+export const PROMPT_00_COMECE_POR_AQUI_MD = `# Start Here (First Use)
+
+If you have never used CodeSDD, follow this order.
+
+## 1) Install And Initialize The Project
+
+In the terminal, from your project directory:
+
+\`\`\`bash
+codesdd install --tools none --lang en-US --layout en-US
+codesdd sdd init --frontend --lang en-US --layout en-US
+codesdd sdd init-context
+codesdd sdd check --render
+codesdd sdd rebuild --from-disk --dry-run
+codesdd sdd dedup --apply --dry-run
+codesdd sdd onboard system
+\`\`\`
+
+## 2) Understand The Main Folders
+
+- \`.sdd/sources/\`: raw material such as PRDs, wireframes, stories, and references.
+- \`.sdd/state/\`: canonical YAML source of truth.
+- \`.sdd/core/\`: generated human-readable system overview.
+- \`.sdd/planning/\`: backlog, progress, and finalize queue.
+- \`.sdd/active/\`: active FEAT workspaces.
+- \`.sdd/archived/\`: finalized workspaces.
+
+CodeSDD is the only operational memory for the project. Do not use external context, memory, workflow, backlog, scratchpad, or handoff stores as active project state.
+
+## 3) I Have PRDs, Wireframes, Or Stories. What Now?
+
+1. Place the files under \`.sdd/sources/\` in the appropriate subfolders.
+2. Run:
+
+\`\`\`bash
+codesdd sdd ingest-deposito --source-dir .sdd/sources --title "Initial system planning"
+\`\`\`
+
+3. Review:
+
+\`\`\`bash
+codesdd sdd check --render
+codesdd sdd next
+\`\`\`
+
+Expected result:
+- sources indexed in \`.sdd/state/source-index.yaml\`
+- EPIC created or reused
+- FEATs generated in the backlog
+- first ready FEAT started automatically when possible
+
+## 4) Execute A Feature
+
+\`\`\`bash
+codesdd sdd start FEAT-0001 --flow-mode standard
+codesdd sdd context FEAT-0001
+codesdd sdd frontend-impact FEAT-0001 --status required --reason "New route and UI components"
+\`\`\`
+
+Implement and update the FEAT package:
+- \`1-spec.yaml\`
+- \`2-plan.yaml\`
+- \`5-quality.yaml\`
+- \`3-tasks.yaml\`
+- \`4-changelog.yaml\`
+
+## 5) Finalize Without Losing Context
+
+\`\`\`bash
+codesdd sdd finalize --ref FEAT-0001
+codesdd sdd check --render
+codesdd sdd onboard system
+\`\`\`
+
+Golden rule:
+- A FEAT is only truly complete after documentation consolidation.
+
+## 6) Short Usage Story
+
+The team placed a PRD and a wireframe in \`.sdd/sources/\`.
+They ran \`codesdd sdd ingest-deposito --source-dir .sdd/sources\` and got an EPIC plus ready FEATs.
+They started the priority FEAT with \`codesdd sdd start FEAT-0001\`.
+Before coding, they ran \`codesdd sdd context FEAT-0001\`.
+After implementation, they ran \`codesdd sdd finalize --ref FEAT-0001\`.
+Result: backlog updated, docs synchronized, and the next FEAT released without guesswork.
+
+## 7) Essential Commands
+
+- \`codesdd sdd onboard system\`: understand the current state.
+- \`codesdd sdd ingest-deposito --source-dir .sdd/sources\`: turn raw material into an executable trail.
+- \`codesdd sdd rebuild --from-disk --dry-run\`: preview state reconciliation from disk artifacts.
+- \`codesdd sdd audit --json\`: persist an audit snapshot in \`.sdd/state/audit-history.yaml\`.
+- \`codesdd sdd metrics --since 7d\`: inspect lead time, aging, and throughput.
+- \`codesdd sdd dedup --apply --dry-run\`: preview historical warning_links reconciliation.
+- \`codesdd sdd lint feature FEAT-0001\`: inspect feature scope before execution.
+- \`codesdd sdd next\`: see what can start now.
+- \`codesdd sdd start FEAT-0001\`: open feature execution.
+- \`codesdd sdd context FEAT-0001\`: generate focused context.
+- \`codesdd sdd frontend-impact FEAT-0001 --status required|none --reason "..."\`: declare frontend impact.
+- \`codesdd sdd finalize --ref FEAT-0001\`: consolidate memory and close.
+`;
+export const PROMPT_01_INGESTAO_DEPOSITO_MD = `# Prompt: Source Intake
+
+Use the skills:
+- source-intake-sdd
+- business-extractor-sdd
+- frontend-extractor-sdd
+- planning-normalizer-sdd
+
+Objective:
+1. Scan \`.sdd/sources/\`.
+2. Update \`.sdd/state/source-index.yaml\`.
+3. Consolidate canonical context (\`architecture\`, \`service-catalog\`, \`tech-stack\`, \`integration-contracts\`, and frontend when enabled).
+4. Generate an executable trail (EPIC plus FEATs) with source traceability.
+
+Required output:
+- summary of sources read;
+- IDs created or updated (EPIC/FEAT/FGAP/INS when ambiguity exists);
+- recommended next CLI commands.
+`;
+export const PROMPT_02_NORMALIZAR_PLANEJAMENTO_MD = `# Prompt: Normalize Planning
+
+Objective:
+Turn consolidated material into an executable plan with clear dependencies.
+
+Instructions:
+1. Start from \`.sdd/state/source-index.yaml\` and \`.sdd/core/*.md\`.
+2. Propose EPICs and FEATs with clear English names.
+3. Define dependencies (\`blocked_by\`) and conflicts (\`lock_domains\`).
+4. List what can run in parallel.
+5. End with a documentation consolidation checklist per feature.
+`;
+export const PROMPT_03_EXECUCAO_FEATURE_MD = `# Prompt: Feature Execution
+
+Objective:
+Execute a FEAT without losing traceability.
+
+Instructions:
+1. Run \`codesdd sdd context FEAT-0001\`.
+2. Update \`.sdd/active/FEAT-0001/\` (spec, plan, tasks, changelog).
+3. Implement.
+4. Update \`.sdd/active/FEAT-0001/5-quality.yaml\` with evidence or a formal exception; quality contracts are blocking by default.
+5. Update affected canonical docs.
+6. Declare frontend impact with \`codesdd sdd frontend-impact FEAT-0001 ...\`.
+7. Ensure architectural-impact FEATs have an ADR before finalize.
+8. Finish with \`codesdd sdd finalize --ref FEAT-0001\`.
+`;
+export const PROMPT_04_CONSOLIDACAO_FINALIZE_MD = `# Prompt: Consolidation And Finalize
+
+Objective:
+Close a feature with complete operational memory.
+
+Checklist:
+1. Review the FEAT technical diff.
+2. Update central documentation (\`README.md\`, \`.sdd/AGENT.md\`, \`.sdd/core/*.md\`, \`AGENTS.md\`, \`AGENT.md\`).
+3. Ensure frontend gaps or decisions are recorded when applicable.
+4. Declare frontend impact with \`codesdd sdd frontend-impact FEAT-0001 --status required|none --reason "..."\`.
+5. Run \`codesdd sdd check --render\`.
+6. Run \`codesdd sdd finalize --ref FEAT-0001\` and report updated docs.
+`;
+export const TEMPLATE_1_SPEC_MD = `schema_version: 1
+feature_id: FEAT-0001
+title: Example workspace specification
+origin:
+  type: direct
+  ref: FEAT-0001
+objective: 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.
+expected_outcome: The feature reaches a verifiable done state with its implementation, documentation, and quality evidence synchronized in CodeSDD.
+system_impact: The workspace keeps canonical state, generated views, and operational handoff aligned with the implementation.
+acceptance_refs:
+  - FEAT-0001
+gates:
+  proposta:
+    status: rascunho
+  planejamento:
+    status: rascunho
+  tarefas:
+    status: rascunho
+compliance_context:
+  jurisdictions:
+    - BR-LGPD
+  data_classes:
+    - personal_data
+  source_refs:
+    - SRC-0001
+  legal_review_required: false
+  legal_review_notes: ""
+created_at: 2026-01-01T00:00:00.000Z
+updated_at: 2026-01-01T00:00:00.000Z
+`;
+export const TEMPLATE_2_PLAN_MD = `schema_version: 1
+feature_id: FEAT-0001
+architectural_impact:
+  description: This plan describes the implementation approach, affected modules, and integration boundaries for the feature.
+  affected_modules:
+    - src
+frontend_impact:
+  status: unknown
+  description: Declare none or required before finalize with ${CLI_NAME} sdd frontend-impact.
+affected_contracts:
+  - name: workspace-documents
+    change_type: example
+quality_strategy:
+  unit_target: 95
+  integration_target: 95
+  approach: hybrid
+suggested_skills:
+  - architecture
+privacy_controls:
+  source_registry_refs:
+    - SRC-0001
+  jurisdiction_profiles:
+    - JP-BR-LGPD
+  control_ids:
+    - CTRL-TRANSPARENCY-001
+  legal_review_gate: conditional
+  unresolved_legal_questions: []
+`;
+export const TEMPLATE_QUALITY_MD = `schema_version: 1
+feature_id: FEAT-0001
+coverage_targets:
+  unit: 95
+  integration: 95
+validation_strategies:
+  - name: Targeted tests
+    command: pnpm test
+    expected: Tests pass for the touched scope.
+evidence_log: []
+skill_evidence:
+  required_skill_ids: []
+  evidence: []
+  verification_rule: No skill evidence required for this feature.
+acceptance_matrix:
+  - criterion: requirements
+    status: not_met
+    evidence: Add validation evidence before finalize.
+exceptions: []
+remediation_policy:
+  on_coverage_miss: block
+  max_rounds: 3
+traceability:
+  spec_anchor:
+    spec_updated_at: ""
+    changelog_refs: []
+  requirements: []
+security_integrity:
+  endpoint_auth_review: pending
+  sensitive_data_exposure_review: pending
+  incident_response_review: pending
+  notes: Record endpoint/data exposure evidence before finalize when privacy impact exists.
+`;
+export const TEMPLATE_3_TASKS_MD = `schema_version: 1
+feature_id: FEAT-0001
+tasks:
+  - id: FEAT-0001-T1
+    phase: preparation
+    title: Load feature context
+    description: Run ${CLI_NAME} sdd context FEAT-0001 and review YAML workspace fields before editing.
+    files_touched: []
+    test_scripts: []
+    acceptance: Context and constraints are understood.
+    status: pending
+  - id: FEAT-0001-T2
+    phase: implementation
+    title: Implement scoped change
+    description: Apply the implementation while preserving CodeSDD state and workspace YAML contracts.
+    files_touched: []
+    test_scripts: []
+    acceptance: The implementation is limited to feature scope.
+    status: pending
+  - id: FEAT-0001-T3
+    phase: testing
+    title: Validate behavior
+    description: Run targeted validation and record results in 5-quality.yaml.
+    files_touched:
+      - .sdd/active/FEAT-0001/5-quality.yaml
+    test_scripts:
+      - command: pnpm test
+        type: unit
+        expected: Tests pass.
+    acceptance: Validation evidence is recorded.
+    status: pending
+  - id: FEAT-0001-T4
+    phase: documentation
+    title: Synchronize documentation
+    description: Update README.md, AGENTS.md, .sdd/AGENT.md, and affected .sdd/core docs when behavior changes.
+    files_touched:
+      - README.md
+      - AGENTS.md
+      - .sdd/AGENT.md
+    test_scripts: []
+    acceptance: Documentation reflects the change or records no-doc-impact.
+    status: pending
+  - id: FEAT-0001-T5
+    phase: finalization
+    title: Finalize feature
+    description: Declare frontend impact, complete 5-quality.yaml evidence, and run ${CLI_NAME} sdd finalize --ref FEAT-0001.
+    files_touched:
+      - .sdd/active/FEAT-0001/5-quality.yaml
+    test_scripts:
+      - command: pnpm run build
+        type: build
+        expected: Build completes successfully.
+    acceptance: The feature finalizes cleanly.
+    status: pending
+`;
+export const TEMPLATE_4_CHANGELOG_MD = `schema_version: 1
+feature_id: FEAT-0001
+entries:
+  - timestamp: 2026-01-01T00:00:00.000Z
+    action: created
+    details: Workspace changelog initialized.
+`;
+//# sourceMappingURL=default-bootstrap-files.js.map