@devtrack-solution/codesdd 1.2.3 → 1.2.4-rc3

package/dist/core/sdd/deepagent-contracts.d.ts

@@ -24,8 +24,8 @@ export declare const deepagentEnvContractSchema: z.ZodObject<{
     sandbox_passthrough_rules: z.ZodDefault<z.ZodArray<z.ZodString>>;
     network_mode: z.ZodDefault<z.ZodEnum<{
         disabled: "disabled";
-        restricted: "restricted";
         enabled: "enabled";
+        restricted: "restricted";
     }>>;
     blocked_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
     masked_config_fingerprint: z.ZodString;
@@ -51,8 +51,8 @@ export declare const deepagentRunRequestSchema: z.ZodObject<{
     network_policy: z.ZodObject<{
         mode: z.ZodDefault<z.ZodEnum<{
             disabled: "disabled";
-            restricted: "restricted";
             enabled: "enabled";
+            restricted: "restricted";
         }>>;
         allowlist: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;
@@ -81,8 +81,8 @@ export declare const deepagentRunRequestSchema: z.ZodObject<{
         sandbox_passthrough_rules: z.ZodDefault<z.ZodArray<z.ZodString>>;
         network_mode: z.ZodDefault<z.ZodEnum<{
             disabled: "disabled";
-            restricted: "restricted";
             enabled: "enabled";
+            restricted: "restricted";
         }>>;
         blocked_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
         masked_config_fingerprint: z.ZodString;
@@ -93,6 +93,100 @@ export declare const deepagentRunRequestSchema: z.ZodObject<{
         capability: z.ZodString;
         version: z.ZodString;
     }, z.core.$strip>>>;
+    change_safety: z.ZodOptional<z.ZodObject<{
+        explicit_modification_intent: z.ZodObject<{
+            operation: z.ZodEnum<{
+                replace: "replace";
+                add: "add";
+                modify: "modify";
+                remove: "remove";
+                refactor: "refactor";
+                optimize: "optimize";
+            }>;
+        }, z.core.$strip>;
+        context_lock: z.ZodDefault<z.ZodObject<{
+            allowed_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            forbidden_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            protected_core: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        change_budget: z.ZodDefault<z.ZodObject<{
+            max_files_changed: z.ZodOptional<z.ZodNumber>;
+            max_new_files: z.ZodOptional<z.ZodNumber>;
+            max_deleted_files: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        governed_override: z.ZodOptional<z.ZodObject<{
+            feature_id: z.ZodString;
+            intent: z.ZodEnum<{
+                replace: "replace";
+                add: "add";
+                modify: "modify";
+                remove: "remove";
+                refactor: "refactor";
+                optimize: "optimize";
+            }>;
+            rationale: z.ZodString;
+            write_scope: z.ZodArray<z.ZodString>;
+            expected_deletions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            rollback_plan: z.ZodString;
+            compensating_control: z.ZodString;
+            approver: z.ZodString;
+            expires_at: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    planned_file_changes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        operation: z.ZodEnum<{
+            replace: "replace";
+            rename: "rename";
+            create: "create";
+            delete: "delete";
+            modify: "modify";
+        }>;
+        previous_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    capability_inventory_before: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            event: "event";
+            schema: "schema";
+            route: "route";
+            page: "page";
+            cli_command: "cli_command";
+            public_contract: "public_contract";
+            core_flow: "core_flow";
+            governance_state: "governance_state";
+        }>;
+        id: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        fingerprint: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    capability_inventory_after: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            event: "event";
+            schema: "schema";
+            route: "route";
+            page: "page";
+            cli_command: "cli_command";
+            public_contract: "public_contract";
+            core_flow: "core_flow";
+            governance_state: "governance_state";
+        }>;
+        id: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        fingerprint: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    capability_inventory_required: z.ZodDefault<z.ZodBoolean>;
+    capability_required_kinds: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        event: "event";
+        schema: "schema";
+        route: "route";
+        page: "page";
+        cli_command: "cli_command";
+        public_contract: "public_contract";
+        core_flow: "core_flow";
+        governance_state: "governance_state";
+    }>>>;
     reversa_scope: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         objective: z.ZodOptional<z.ZodString>;
@@ -157,8 +251,8 @@ export declare const deepagentToolCallEvidenceSchema: z.ZodObject<{
     }>;
     policy_gate: z.ZodString;
     hitl_decision: z.ZodDefault<z.ZodEnum<{
-        edit: "edit";
         none: "none";
+        edit: "edit";
         approve: "approve";
         reject: "reject";
         respond: "respond";

package/dist/core/sdd/deepagent-contracts.js

@@ -10,6 +10,18 @@ const deepagentModeSchema = z.enum([
 const deepagentStatusSchema = z.enum(['allowed', 'blocked', 'running', 'completed', 'failed']);
 const deepagentNetworkModeSchema = z.enum(['disabled', 'restricted', 'enabled']);
 const deepagentRuntimeModeSchema = z.enum(['disabled', 'fake', 'deepagents-js']);
+const changeSafetyOperationSchema = z.enum(['add', 'modify', 'remove', 'replace', 'refactor', 'optimize']);
+const plannedFileOperationSchema = z.enum(['create', 'modify', 'delete', 'rename', 'replace']);
+const capabilityKindSchema = z.enum([
+    'route',
+    'page',
+    'cli_command',
+    'public_contract',
+    'schema',
+    'event',
+    'core_flow',
+    'governance_state',
+]);
 const deepagentExecutionLimitsSchema = z.object({
     max_iterations: z.number().int().positive().optional(),
     max_subagents: z.number().int().positive().optional(),
@@ -20,6 +32,50 @@ const deepagentEvidenceRefSchema = z.object({
     ref: z.string().min(1),
     path: z.string().min(1).optional(),
 });
+const changeSafetyContractSchema = z.object({
+    explicit_modification_intent: z.object({
+        operation: changeSafetyOperationSchema,
+    }),
+    context_lock: z
+        .object({
+        allowed_paths: z.array(z.string().min(1)).default([]),
+        forbidden_paths: z.array(z.string().min(1)).default([]),
+        protected_core: z.array(z.string().min(1)).default([]),
+    })
+        .default({ allowed_paths: [], forbidden_paths: [], protected_core: [] }),
+    change_budget: z
+        .object({
+        max_files_changed: z.number().int().nonnegative().optional(),
+        max_new_files: z.number().int().nonnegative().optional(),
+        max_deleted_files: z.number().int().nonnegative().optional(),
+    })
+        .default({}),
+    governed_override: z
+        .object({
+        feature_id: z.string().regex(FEATURE_REF_PATTERN),
+        intent: changeSafetyOperationSchema,
+        rationale: z.string().min(1),
+        write_scope: z.array(z.string().min(1)).min(1),
+        expected_deletions: z.array(z.string().min(1)).default([]),
+        rollback_plan: z.string().min(1),
+        compensating_control: z.string().min(1),
+        approver: z.string().min(1),
+        expires_at: z.string().datetime(),
+    })
+        .optional(),
+});
+const plannedFileChangeSchema = z.object({
+    path: z.string().min(1),
+    operation: plannedFileOperationSchema,
+    previous_path: z.string().min(1).optional(),
+});
+const capabilityInventoryItemSchema = z.object({
+    kind: capabilityKindSchema,
+    id: z.string().min(1),
+    path: z.string().min(1).optional(),
+    fingerprint: z.string().min(1).optional(),
+    metadata: z.record(z.string(), z.unknown()).default({}),
+});
 const deepagentRiskSchema = z.object({
     id: z.string().min(1),
     severity: z.enum(['low', 'medium', 'high', 'critical']),
@@ -70,6 +126,12 @@ export const deepagentRunRequestSchema = z.object({
         version: z.string().min(1),
     }))
         .default([]),
+    change_safety: changeSafetyContractSchema.optional(),
+    planned_file_changes: z.array(plannedFileChangeSchema).default([]),
+    capability_inventory_before: z.array(capabilityInventoryItemSchema).default([]),
+    capability_inventory_after: z.array(capabilityInventoryItemSchema).default([]),
+    capability_inventory_required: z.boolean().default(false),
+    capability_required_kinds: z.array(capabilityKindSchema).default([]),
     reversa_scope: z.object({
         enabled: z.boolean().default(false),
         objective: z.string().min(1).optional(),

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

@@ -10,10 +10,10 @@ 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 --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.\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;

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

@@ -25,6 +25,8 @@ This directory stores the project's operational memory.
 10. \`${memoryDir}/core/frontend-decisions.md\` (when frontend is enabled)
 
 ## How To Operate
+CodeSDD is the official planner for initialized repositories. Any request that implies implementation, file edits, validation, execution, or finalize implicitly requires the CodeSDD flow unless the user explicitly marks it as read-only or outside CodeSDD.
+
 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.
@@ -50,6 +52,7 @@ This directory stores the project's operational memory.
 - \`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.
+- Agent-native plans and other planners may only refine execution after \`${CLI_NAME} sdd next\` and \`${CLI_NAME} sdd context <FEAT-ID>\` bind the request to a CodeSDD FEAT.
 
 ## Operational Rule
 Every completed feature must update relevant documentation before \`finalize\`.
@@ -98,6 +101,7 @@ codesdd reload --tools none --lang en-US --layout en-US
 - \`.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.
+In initialized CodeSDD repositories, requests that imply implementation, edits, validation, execution, or finalize implicitly require CodeSDD planning unless explicitly marked read-only or outside CodeSDD.
 
 ## 3) I Have PRDs, Wireframes, Or Stories. What Now?
 
@@ -208,14 +212,16 @@ 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\`.
+1. 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.
+2. Run \`codesdd sdd next\` and bind the work to the active or ready FEAT returned by CodeSDD.
+3. Run \`codesdd sdd context FEAT-0001\`.
+4. Update \`.sdd/active/FEAT-0001/\` (spec, plan, tasks, changelog).
+5. Implement.
+6. Update \`.sdd/active/FEAT-0001/5-quality.yaml\` with evidence or a formal exception; quality contracts are blocking by default.
+7. Update affected canonical docs.
+8. Declare frontend impact with \`codesdd sdd frontend-impact FEAT-0001 ...\`.
+9. Ensure architectural-impact FEATs have an ADR before finalize.
+10. Finish with \`codesdd sdd finalize --ref FEAT-0001\`.
 `;
 export const PROMPT_04_CONSOLIDACAO_FINALIZE_MD = `# Prompt: Consolidation And Finalize
 

package/dist/core/sdd/default-skills.js

@@ -5,11 +5,50 @@ import { fileURLToPath } from 'node:url';
 import { CLI_NAME } from '../branding.js';
 import { DEVTRACK_API_APPLIANCE_PLUGIN_ID } from './devtrack-api-appliance.js';
 const DEFAULT_TOOLS = ['codex', 'cursor', 'claude', 'gemini'];
+const DEVTRACK_PORTABLE_TOOLS = ['codex', 'cursor', 'claude', 'gemini', 'kimi', 'opencode'];
+const DEVTRACK_API_DOMAINS = ['architecture', 'backend', 'api', 'nestjs', 'typeorm', 'devtrack', 'foundation'];
+const DEVTRACK_ANGULAR_DOMAINS = [
+    'admin',
+    'angular-admin',
+    'backoffice',
+    'operational-ui',
+    'dashboard',
+    'crud',
+    'data-grid',
+    'admin-forms',
+    'admin-formly',
+    'admin-state',
+    'ngxs-admin',
+    'permissions',
+    'reports',
+    'workflow',
+    'admin-realtime',
+    'admin-chat',
+];
+const DEVTRACK_FLUTTER_DOMAINS = [
+    'flutter',
+    'dart',
+    'cross-platform',
+    'flutter-ui',
+    'flutter-layout',
+    'flutter-routing',
+    'flutter-l10n',
+    'flutter-http',
+    'flutter-json',
+    'widget-preview',
+    'widget-test',
+    'integration-test',
+    'go-router',
+    'arb',
+    'l10n',
+];
 const DEFAULT_SOURCE_REPO = 'https://github.com/sickn33/antigravity-awesome-skills';
 const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../');
 const LOCAL_SDD_SKILL_PATHS = {
     'api-clean-flask-langgraph': '.sdd/skills/curated/api-clean-flask-langgraph/SKILL.md',
     'devtrack-api': '.sdd/skills/curated/devtrack-api/SKILL.md',
+    'devtrack-angular': '.sdd/skills/curated/devtrack-angular/SKILL.md',
+    'devtrack-flutter': '.sdd/skills/curated/devtrack-flutter/SKILL.md',
     'source-intake-sdd': '.sdd/skills/curated/source-intake-sdd/SKILL.md',
     'business-extractor-sdd': '.sdd/skills/curated/business-extractor-sdd/SKILL.md',
     'frontend-extractor-sdd': '.sdd/skills/curated/frontend-extractor-sdd/SKILL.md',
@@ -37,6 +76,14 @@ const SKILL_METADATA_OVERRIDES = {
         title: 'DevTrack API',
         description: 'Model-agnostic backend engineering and governance skill for DevTrack APIs using NestJS, TypeORM, DDD/Clean Architecture boundaries, evidence-based validation, and safe operational delivery.',
     },
+    'devtrack-angular': {
+        title: 'DevTrack Angular Admin',
+        description: 'Portable Angular Admin engineering and governance skill for DevTrack backoffice surfaces using pages-first architecture, standalone components, lazy admin routes, official Angular skills mapping, Formly, NGXS, data grids, permissions, adapters, accessibility, and multi-agent delivery.',
+    },
+    'devtrack-flutter': {
+        title: 'DevTrack Flutter',
+        description: 'Portable Flutter/Dart engineering and governance skill for DevTrack apps using layered architecture, MVVM/ViewModels, repositories, services, go_router, ARB/l10n, http, JSON mapping, responsive layout, previews, tests, and multi-agent delivery.',
+    },
 };
 const CURATED_BUNDLES = [
     {
@@ -101,6 +148,8 @@ const CURATED_BUNDLES = [
         domains: ['frontend', 'product'],
         phases: ['plan', 'execute', 'verify'],
         skillIds: [
+            'devtrack-angular',
+            'devtrack-flutter',
             'frontend-design',
             'react-best-practices',
             'react-patterns',
@@ -214,6 +263,12 @@ function priorityForIndex(index) {
     const priority = 10 - index;
     return priority < 6 ? 6 : priority;
 }
+function priorityForSkill(skillId, index) {
+    if (skillId === 'devtrack-api' || skillId === 'devtrack-angular' || skillId === 'devtrack-flutter') {
+        return 10;
+    }
+    return priorityForIndex(index);
+}
 export function normalizeSkillManifestContent(content) {
     return content
         .replaceAll('.sdd/deposito', '.sdd/sources')
@@ -253,11 +308,28 @@ function seedIntegrityHash(entry) {
     }
     return computeSkillManifestSha256(fallbackSkillMarkdown(entry));
 }
+function toolsForSkill(skillId) {
+    return skillId === 'devtrack-api' || skillId === 'devtrack-angular' || skillId === 'devtrack-flutter'
+        ? DEVTRACK_PORTABLE_TOOLS
+        : DEFAULT_TOOLS;
+}
+function domainsForSkill(bundle, skillId) {
+    if (skillId === 'devtrack-api') {
+        return DEVTRACK_API_DOMAINS;
+    }
+    if (skillId === 'devtrack-angular') {
+        return DEVTRACK_ANGULAR_DOMAINS;
+    }
+    if (skillId === 'devtrack-flutter') {
+        return DEVTRACK_FLUTTER_DOMAINS;
+    }
+    return bundle.domains;
+}
 function buildSkillEntry(bundle, skillId, index) {
     const localSourcePath = LOCAL_SDD_SKILL_PATHS[skillId];
     const isLocalSkill = Boolean(localSourcePath);
     const metadata = SKILL_METADATA_OVERRIDES[skillId] || {};
-    const sourceRepo = isLocalSkill ? 'local://legacy-spec/sdd' : DEFAULT_SOURCE_REPO;
+    const sourceRepo = isLocalSkill ? 'local://CodeSDD/sdd' : DEFAULT_SOURCE_REPO;
     const sourcePath = isLocalSkill ? localSourcePath : `skills/${skillId}/SKILL.md`;
     const deterministicPair = skillId === 'devtrack-api'
         ? { plugin_id: DEVTRACK_API_APPLIANCE_PLUGIN_ID, capability: 'scaffold.project' }
@@ -271,10 +343,10 @@ function buildSkillEntry(bundle, skillId, index) {
             ? `Native SDD skill for ${bundle.title.toLowerCase()}.`
             : `Curated skill for ${bundle.title.toLowerCase()} in the SDD flow.`),
         phases: bundle.phases,
-        domains: bundle.domains,
-        tools: DEFAULT_TOOLS,
+        domains: domainsForSkill(bundle, skillId),
+        tools: toolsForSkill(skillId),
         bundle_ids: [bundle.id],
-        priority: priorityForIndex(index),
+        priority: priorityForSkill(skillId, index),
         token_budget: {
             input_max: 12000,
             output_max: 4000,
@@ -486,6 +558,24 @@ export function buildCuratedBundlesCurationData(layout = 'en-US') {
                 'Operational default: API/backend work uses devtrack-api unless an explicit skill/profile overrides it; Python/Flask API work uses api-clean-flask-langgraph.',
             ],
         },
+        {
+            skill_id: 'devtrack-angular',
+            bundle_id: 'frontend-product',
+            canonical_path: '.sdd/skills/curated/devtrack-angular/',
+            notes: [
+                'Canonical directory for the DevTrack Angular Admin skill; includes agents/ and references/.',
+                'Operational default: Angular Admin/backoffice work that names admin pages, dashboards, CRUD, data grids, admin Formly, admin NGXS/state, official Angular framework patterns, permissions, reports, workflow, admin realtime, or admin chat should use devtrack-angular unless an explicit skill/profile overrides it.',
+            ],
+        },
+        {
+            skill_id: 'devtrack-flutter',
+            bundle_id: 'frontend-product',
+            canonical_path: '.sdd/skills/curated/devtrack-flutter/',
+            notes: [
+                'Canonical directory for the DevTrack Flutter skill; includes agents/ and references/.',
+                'Operational default: Flutter/Dart work that names Flutter apps, widgets, routing, localization, responsive layout, JSON, HTTP, previews, widget tests, integration tests, go_router, ARB, or l10n should use devtrack-flutter unless an explicit skill/profile overrides it.',
+            ],
+        },
     ];
     const operational_rule = layout === 'en-US'
         ? [
@@ -531,6 +621,12 @@ export function buildCuratedBundlesMarkdown() {
     lines.push('- `devtrack-api` belongs to bundle `architecture-backend`.');
     lines.push('- Canonical directory: `.sdd/skills/curated/devtrack-api/` (includes `agents/` and `references/`).');
     lines.push('- Operational default: API/backend work uses `devtrack-api` unless an explicit skill/profile overrides it; Python/Flask API work uses `api-clean-flask-langgraph`.');
+    lines.push('- `devtrack-angular` belongs to bundle `frontend-product` as the Angular Admin/backoffice skill.');
+    lines.push('- Canonical directory: `.sdd/skills/curated/devtrack-angular/` (includes `agents/` and `references/`).');
+    lines.push('- Operational default: Angular Admin/backoffice work that names admin pages, dashboards, CRUD, data grids, admin Formly, admin NGXS/state, official Angular framework patterns, permissions, reports, workflow, admin realtime, or admin chat should use `devtrack-angular` unless an explicit skill/profile overrides it.');
+    lines.push('- `devtrack-flutter` belongs to bundle `frontend-product` as the Flutter/Dart product skill.');
+    lines.push('- Canonical directory: `.sdd/skills/curated/devtrack-flutter/` (includes `agents/` and `references/`).');
+    lines.push('- Operational default: Flutter/Dart work that names Flutter apps, widgets, routing, localization, responsive layout, JSON, HTTP, previews, widget tests, integration tests, go_router, ARB, or l10n should use `devtrack-flutter` unless an explicit skill/profile overrides it.');
     lines.push('');
     lines.push('## Canonical Source');
     lines.push('- `.sdd/state/skill-catalog.yaml`');
@@ -599,5 +695,13 @@ export const BUILT_IN_SDD_SKILLS = {
         kind: 'source-tree',
         sourceRoot: '.sdd/skills/curated/devtrack-api',
     },
+    'devtrack-angular': {
+        kind: 'source-tree',
+        sourceRoot: '.sdd/skills/curated/devtrack-angular',
+    },
+    'devtrack-flutter': {
+        kind: 'source-tree',
+        sourceRoot: '.sdd/skills/curated/devtrack-flutter',
+    },
 };
 //# sourceMappingURL=default-skills.js.map

package/dist/core/sdd/devtrack-api-appliance.d.ts

@@ -1,16 +1,23 @@
 import { type PluginArtifactManifest, type PluginRuntimeInvocationPlan } from './plugin-broker.js';
 import { type PluginManifest } from './plugin-manifest.js';
+import type { PluginArtifactKind, PluginArtifactMapEntry, PluginArtifactRole } from './plugin-sdk-contract.js';
 export declare const DEVTRACK_API_APPLIANCE_PLUGIN_ID = "codesdd-plugin-devtrack-api";
 export declare const DEVTRACK_API_APPLIANCE_CAPABILITIES: readonly ["scaffold.project", "generate.domain", "generate.crud", "validate.structure", "evidence.emit"];
 declare const DEVTRACK_API_SCAFFOLD_CAPABILITY = "scaffold.project";
-type DevTrackApiScaffoldLayer = 'root' | 'application' | 'domain' | 'infrastructure' | 'presentation' | 'shared' | 'tests' | 'docs';
+type DevTrackApiScaffoldLayer = 'root' | 'application' | 'domain' | 'infrastructure' | 'presentation' | 'shared' | 'tests' | 'docs' | 'config' | 'sdd' | 'assets';
 export interface DevTrackApiScaffoldArtifact {
     path: string;
     layer: DevTrackApiScaffoldLayer;
     operation: 'planned';
+    artifact_kind: PluginArtifactKind;
+    role: PluginArtifactRole;
     content_type: string;
     reason: string;
     source_reference: string;
+    language?: PluginArtifactMapEntry['language'];
+    implementation: PluginArtifactMapEntry['implementation'];
+    decision_refs: string[];
+    tags: string[];
 }
 export interface DevTrackApiScaffoldDryRunInput {
     feature_ref: string;

package/dist/core/sdd/devtrack-api-appliance.js

@@ -107,6 +107,14 @@ export function buildDevTrackApiScaffoldDryRunPlan(manifest, input) {
                 operation: artifact.operation,
                 reason: artifact.reason,
                 content_type: artifact.content_type,
+                artifact_kind: artifact.artifact_kind,
+                role: artifact.role,
+                layer: artifact.layer,
+                language: artifact.language,
+                implementation: artifact.implementation,
+                decision_refs: artifact.decision_refs,
+                source_refs: [artifact.source_reference],
+                tags: artifact.tags,
             })),
             validation_evidence: parsed.validation.commands.map((command) => ({
                 command,
@@ -210,37 +218,52 @@ function buildEvidenceManifest(input) {
 }
 function buildScaffoldArtifacts() {
     return [
-        artifact('package.json', 'root', 'application/json', 'Foundation-compatible package metadata, scripts, and dependencies.'),
-        artifact('tsconfig.json', 'root', 'application/json', 'TypeScript path aliases and compiler settings aligned to Foundation API.'),
-        artifact('nest-cli.json', 'root', 'application/json', 'Nest CLI configuration with Swagger plugin support.'),
-        artifact('eslint.config.mjs', 'root', 'text/javascript', 'Foundation-compatible lint rules and import-boundary checks.'),
-        artifact('docs/foundation-backend-reference-structure.md', 'docs', 'text/markdown', 'Derived Foundation package structure reference for maintainers.'),
-        artifact('src/main.ts', 'root', 'text/typescript', 'NestJS bootstrap entrypoint.'),
-        artifact('src/app.module.ts', 'root', 'text/typescript', 'Root module composing application, infrastructure, and presentation layers.'),
-        artifact('src/application/application.module.ts', 'application', 'text/typescript', 'Application layer module boundary.'),
-        artifact('src/application/runtime-settings.ts', 'application', 'text/typescript', 'Application runtime settings boundary.'),
-        artifact('src/domain/auth/api-keys.domain.ts', 'domain', 'text/typescript', 'Initial domain object example from Foundation API.'),
-        artifact('src/infrastructure/infrastructure.module.ts', 'infrastructure', 'text/typescript', 'Infrastructure layer module boundary.'),
-        artifact('src/infrastructure/settings/app-configuration.ts', 'infrastructure', 'text/typescript', 'Typed application configuration source.'),
-        artifact('src/presentation/presentation.module.ts', 'presentation', 'text/typescript', 'Presentation layer module boundary.'),
-        artifact('src/presentation/rest/rest.presentation.module.ts', 'presentation', 'text/typescript', 'REST channel module boundary.'),
-        artifact('src/presentation/graphql/graphql.presentation.module.ts', 'presentation', 'text/typescript', 'GraphQL channel module boundary.'),
-        artifact('src/presentation/cli/cli.presentation.module.ts', 'presentation', 'text/typescript', 'CLI channel module boundary.'),
-        artifact('src/presentation/websocket/websocket.module.ts', 'presentation', 'text/typescript', 'WebSocket channel module boundary.'),
-        artifact('src/shared/domain/generic-business-object.ts', 'shared', 'text/typescript', 'Shared domain primitive used by Foundation packages.'),
-        artifact('src/shared/presentation/generic-controller.ts', 'shared', 'text/typescript', 'Shared presentation primitive used by REST controllers.'),
-        artifact('tests/app.e2e-spec.ts', 'tests', 'text/typescript', 'Initial E2E smoke test for the generated API scaffold.'),
-        artifact('tests/jest-e2e.json', 'tests', 'application/json', 'Jest E2E configuration for the scaffold.'),
+        artifact('package.json', 'root', 'package-metadata', 'manifest', 'application/json', 'Foundation-compatible package metadata, scripts, and dependencies.'),
+        artifact('tsconfig.json', 'config', 'configuration', 'manifest', 'application/json', 'TypeScript path aliases and compiler settings aligned to Foundation API.'),
+        artifact('nest-cli.json', 'config', 'configuration', 'manifest', 'application/json', 'Nest CLI configuration with Swagger plugin support.'),
+        artifact('eslint.config.mjs', 'config', 'configuration', 'policy', 'text/javascript', 'Foundation-compatible lint rules and import-boundary checks.'),
+        artifact('docs/foundation-backend-reference-structure.md', 'docs', 'documentation', 'documentation', 'text/markdown', 'Derived Foundation package structure reference for maintainers.'),
+        artifact('src/main.ts', 'root', 'source', 'implementation', 'text/typescript', 'NestJS bootstrap entrypoint.'),
+        artifact('src/app.module.ts', 'root', 'source', 'module', 'text/typescript', 'Root module composing application, infrastructure, and presentation layers.'),
+        artifact('src/application/application.module.ts', 'application', 'source', 'module', 'text/typescript', 'Application layer module boundary.'),
+        artifact('src/application/runtime-settings.ts', 'application', 'source', 'type', 'text/typescript', 'Application runtime settings boundary.'),
+        artifact('src/domain/auth/business-objects/api-keys.bo.ts', 'domain', 'source', 'business-object', 'text/typescript', 'Initial BO-pattern domain object example from Foundation API.'),
+        artifact('src/application/business/auth/ports/out/api-key-repository.port.ts', 'application', 'source', 'repository-port', 'text/typescript', 'BO-pattern repository port owned by application ports/out.'),
+        artifact('src/infrastructure/infrastructure.module.ts', 'infrastructure', 'source', 'module', 'text/typescript', 'Infrastructure layer module boundary.'),
+        artifact('src/infrastructure/settings/app-configuration.ts', 'infrastructure', 'source', 'implementation', 'text/typescript', 'Typed application configuration source.'),
+        artifact('src/infrastructure/adapters/orm/entities/api-key.orm-entity.ts', 'infrastructure', 'source', 'entity', 'text/typescript', 'TypeORM persistence entity kept in the centralized orm subsystem.'),
+        artifact('src/presentation/presentation.module.ts', 'presentation', 'source', 'module', 'text/typescript', 'Presentation layer module boundary.'),
+        artifact('src/presentation/rest/rest.presentation.module.ts', 'presentation', 'source', 'module', 'text/typescript', 'REST channel module boundary.'),
+        artifact('src/presentation/graphql/graphql.presentation.module.ts', 'presentation', 'source', 'module', 'text/typescript', 'GraphQL channel module boundary.'),
+        artifact('src/presentation/cli/cli.presentation.module.ts', 'presentation', 'source', 'module', 'text/typescript', 'CLI channel module boundary.'),
+        artifact('src/presentation/websocket/websocket.module.ts', 'presentation', 'source', 'module', 'text/typescript', 'WebSocket channel module boundary.'),
+        artifact('src/shared/domain/generic-business-object.ts', 'shared', 'source', 'abstraction', 'text/typescript', 'Shared domain primitive used by Foundation packages.'),
+        artifact('src/shared/presentation/generic-controller.ts', 'shared', 'source', 'abstraction', 'text/typescript', 'Shared presentation primitive used by REST controllers.'),
+        artifact('tests/app.e2e-spec.ts', 'tests', 'test', 'test', 'text/typescript', 'Initial E2E smoke test for the generated API scaffold.'),
+        artifact('tests/jest-e2e.json', 'tests', 'configuration', 'manifest', 'application/json', 'Jest E2E configuration for the scaffold.'),
     ];
 }
-function artifact(artifactPath, layer, contentType, reason) {
-    return {
+function artifact(artifactPath, layer, artifactKind, role, contentType, reason) {
+    const mapEntry = {
         path: artifactPath,
         layer,
         operation: 'planned',
+        artifact_kind: artifactKind,
+        role,
         content_type: contentType,
         reason,
+        language: contentType.includes('typescript') || contentType.includes('javascript') ? 'typescript' : undefined,
+        implementation: role === 'interface' || role === 'repository-port' ? 'contract' : 'generated',
+        decision_refs: ['EPIC-0075'],
+        source_refs: [`${DEVTRACK_API_REFERENCE_ROOT}/${artifactPath}`],
+        tags: ['devtrack-api', 'foundation-api'],
+        metadata: {},
+    };
+    return {
+        ...mapEntry,
         source_reference: `${DEVTRACK_API_REFERENCE_ROOT}/${artifactPath}`,
+        decision_refs: mapEntry.decision_refs,
+        tags: mapEntry.tags,
     };
 }
 function normalizePackageName(value) {