agent-devkit 0.1.5 → 0.2.0

package/runtime/agents/aws-lambda-builder/knowledge/context.md

@@ -0,0 +1,12 @@
+# Contexto
+
+O projeto ja possui agentes AWS para analise, auditoria e operacoes. Este agente
+nao substitui essas responsabilidades:
+
+- `aws-operations-operator` opera recursos existentes com confirmacao.
+- `aws-security-governance-auditor` audita recursos existentes.
+- `aws-architecture-analyst` analisa workloads existentes.
+
+O `aws-lambda-builder` cria artefatos locais para novas Lambdas e planos de
+deploy revisaveis. Deploy real deve ser implementado futuramente como capability
+separada com `write_policy: confirm`.

package/runtime/agents/aws-lambda-builder/knowledge/policies.yaml

@@ -0,0 +1,23 @@
+write_policy:
+  planning: read_only
+  project_generation: local_write
+  security_review: read_only
+  package_local: local_write
+  deploy_plan: dry_run
+  deploy_real: blocked_by_default
+supported_runtime_families:
+  - python
+  - nodejs
+supported_triggers:
+  - api-gateway
+  - eventbridge-schedule
+  - sqs
+  - sns
+  - s3-event
+  - manual-test-event
+guardrails:
+  block_hardcoded_secrets: true
+  block_unjustified_iam_wildcards: true
+  require_local_tests: true
+  require_event_fixture: true
+  prohibit_real_deploy: true

package/runtime/agents/aws-lambda-builder/knowledge/system.md

@@ -0,0 +1,10 @@
+# System
+
+Voce e o `aws-lambda-builder`, especialista em gerar projetos AWS Lambda sem
+executar deploy real. Seu trabalho e produzir planos e artefatos locais
+revisaveis: handler, fixtures, testes, template SAM, revisao de seguranca,
+pacote zip local e plano de deploy.
+
+Nunca invoque AWS CLI, SAM deploy, Serverless deploy ou CDK deploy. Quando o
+usuario pedir deploy, gere plano e checklist, deixando claro que `deploy_real`
+e falso nesta capability.

package/runtime/agents/aws-lambda-builder/templates/lambda-deploy-plan.md

@@ -0,0 +1,3 @@
+# Lambda Deploy Plan
+
+Template rendered by `deploy-lambda-plan`.

package/runtime/agents/aws-lambda-builder/templates/lambda-package.md

@@ -0,0 +1,3 @@
+# Lambda Package
+
+Template rendered by `package-lambda`.

package/runtime/agents/aws-lambda-builder/templates/lambda-plan.md

@@ -0,0 +1,3 @@
+# Lambda Plan
+
+Template rendered by `plan-lambda`.

package/runtime/agents/aws-lambda-builder/templates/lambda-readme.md

@@ -0,0 +1,3 @@
+# Lambda Project
+
+Template rendered by `generate-lambda-project`.

package/runtime/agents/aws-lambda-builder/templates/lambda-security-review.md

@@ -0,0 +1,3 @@
+# Lambda Security Review
+
+Template rendered by `review-lambda-security`.

package/runtime/agents/aws-lambda-builder/tests/test_runners.py

@@ -0,0 +1,355 @@
+#!/usr/bin/env python3
+"""Tests for the AWS Lambda Builder runners."""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import py_compile
+import subprocess
+import sys
+import tempfile
+import unittest
+import zipfile
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[3]
+AGENT = ROOT / "agent"
+AGENT_DIR = ROOT / "agents" / "aws-lambda-builder"
+REPOSITORY_PATH = AGENT_DIR / "infra" / "integrations" / "aws-lambda" / "aws_lambda_repository.py"
+
+
+def load_repository_module():
+    spec = importlib.util.spec_from_file_location("aws_lambda_repository", REPOSITORY_PATH)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"cannot load repository from {REPOSITORY_PATH}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+class AwsLambdaBuilderRunnersTest(unittest.TestCase):
+    def setUp(self) -> None:
+        self.repository_module = load_repository_module()
+
+    def write_spec(
+        self,
+        root: Path,
+        *,
+        lambda_name: str = "Orders Webhook",
+        target_project: Path | None = None,
+        runtime_family: str = "python",
+        runtime: str = "python3.12",
+        handler: str = "handler.lambda_handler",
+        trigger: str = "api-gateway",
+        deploy_strategy: str = "sam",
+        env_value: str = "${APP_TABLE_NAME}",
+        iam_action: str = "dynamodb:PutItem",
+        iam_resource: str = "arn:aws:dynamodb:us-east-1:123456789012:table/orders",
+        iam_justification: str = "",
+        observability_extra: str = "  dlq_or_destination: arn:aws:sqs:us-east-1:123456789012:orders-dlq\n",
+        purpose: str = "Receive order webhooks and enqueue normalized events.",
+    ) -> Path:
+        path = root / "lambda-spec.yaml"
+        target_project_line = f"target_project: {target_project}\n" if target_project else ""
+        path.write_text(
+            f"""
+lambda_name: {json.dumps(lambda_name)}
+{target_project_line}purpose: {json.dumps(purpose)}
+runtime_family: {json.dumps(runtime_family)}
+runtime: {json.dumps(runtime)}
+handler: {json.dumps(handler)}
+trigger: {json.dumps(trigger)}
+deploy_strategy: {json.dumps(deploy_strategy)}
+timeout_seconds: 30
+memory_mb: 256
+input_schema:
+  type: object
+output_schema:
+  type: object
+environment_variables:
+  - name: APP_TABLE_NAME
+    value: {json.dumps(env_value)}
+iam_permissions:
+  - action: {json.dumps(iam_action)}
+    resource: {json.dumps(iam_resource)}
+    justification: {json.dumps(iam_justification)}
+observability:
+  structured_logging: true
+{observability_extra}""".lstrip(),
+            encoding="utf-8",
+        )
+        return path
+
+    def test_plan_lambda_returns_plan_without_writing(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            spec_path = self.write_spec(root)
+            repository = self.repository_module.AwsLambdaRepository(root=root)
+
+            result = repository.plan_lambda(spec_path=spec_path)
+
+            self.assertEqual(result["status"], "ok")
+            self.assertEqual(result["lambda"]["slug"], "orders-webhook")
+            self.assertEqual(result["write_policy"], "read_only")
+            planned_paths = {item["path"] for item in result["planned_artifacts"]}
+            self.assertGreaterEqual(planned_paths, {"src/handler.py", "tests/test_handler.py", "template.yaml"})
+            self.assertFalse((root / "src").exists())
+
+    def test_plan_lambda_reports_needs_input(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            spec_path = root / "lambda-spec.yaml"
+            spec_path.write_text("lambda_name: incomplete\n", encoding="utf-8")
+            repository = self.repository_module.AwsLambdaRepository(root=root)
+
+            result = repository.plan_lambda(spec_path=spec_path)
+
+            self.assertEqual(result["status"], "needs-input")
+            self.assertGreaterEqual(
+                set(result["missing_fields"]),
+                {
+                    "purpose",
+                    "runtime_family",
+                    "runtime",
+                    "handler",
+                    "trigger",
+                    "input_schema",
+                    "output_schema",
+                    "environment_variables",
+                    "iam_permissions",
+                    "observability",
+                    "timeout_seconds",
+                    "memory_mb",
+                    "deploy_strategy",
+                },
+            )
+
+    def test_plan_blocks_invalid_trigger(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            spec_path = self.write_spec(root, trigger="kinesis")
+            repository = self.repository_module.AwsLambdaRepository(root=root)
+
+            result = repository.plan_lambda(spec_path=spec_path)
+
+            self.assertEqual(result["status"], "blocked")
+            self.assertEqual(result["reason"], "unsupported_trigger")
+
+    def test_plan_blocks_invalid_runtime_family(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            spec_path = self.write_spec(root, runtime_family="ruby", runtime="ruby3.3")
+            repository = self.repository_module.AwsLambdaRepository(root=root)
+
+            result = repository.plan_lambda(spec_path=spec_path)
+
+            self.assertEqual(result["status"], "blocked")
+            self.assertEqual(result["reason"], "unsupported_runtime_family")
+
+    def test_plan_blocks_hardcoded_secret_env_value(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            spec_path = self.write_spec(root, env_value="plain-token", purpose="Uses API_TOKEN: plain-token")
+            repository = self.repository_module.AwsLambdaRepository(root=root)
+
+            result = repository.plan_lambda(spec_path=spec_path)
+
+            self.assertEqual(result["status"], "blocked")
+            self.assertEqual(result["reason"], "security_guardrail_failed")
+            codes = {finding["code"] for finding in result["findings"]}
+            self.assertIn("hardcoded_secret_marker", codes)
+
+    def test_plan_blocks_iam_wildcard_without_justification(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            spec_path = self.write_spec(root, iam_action="dynamodb:*", iam_resource="*")
+            repository = self.repository_module.AwsLambdaRepository(root=root)
+
+            result = repository.plan_lambda(spec_path=spec_path)
+
+            self.assertEqual(result["status"], "blocked")
+            codes = {finding["code"] for finding in result["findings"]}
+            self.assertIn("iam_action_wildcard_without_justification", codes)
+
+    def test_review_lambda_security_warns_resource_wildcard_when_justified(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            spec_path = self.write_spec(
+                root,
+                iam_action="dynamodb:*",
+                iam_resource="*",
+                iam_justification="temporary bootstrap until table ARNs are known",
+            )
+            repository = self.repository_module.AwsLambdaRepository(root=root)
+
+            result = repository.review_lambda_security(spec_path=spec_path)
+
+            self.assertEqual(result["status"], "ok")
+            self.assertTrue(result["valid"])
+            codes = {finding["code"] for finding in result["findings"]}
+            self.assertIn("iam_resource_wildcard", codes)
+
+    def test_generate_lambda_project_dry_run_does_not_write(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            target_project = root / "target-project"
+            target_project.mkdir()
+            spec_path = self.write_spec(root, target_project=target_project)
+            repository = self.repository_module.AwsLambdaRepository(root=root)
+
+            result = repository.generate_lambda_project(spec_path=spec_path)
+
+            self.assertEqual(result["status"], "planned")
+            self.assertTrue(result["dry_run"])
+            planned_paths = {item["path"] for item in result["planned_files"]}
+            self.assertGreaterEqual(
+                planned_paths,
+                {
+                    "orders-webhook/src/handler.py",
+                    "orders-webhook/tests/test_handler.py",
+                    "orders-webhook/events/api-gateway.json",
+                    "orders-webhook/template.yaml",
+                },
+            )
+            self.assertFalse((target_project / "orders-webhook").exists())
+
+    def test_generate_python_project_execute_writes_inside_target_project(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            target_project = root / "target-project"
+            target_project.mkdir()
+            spec_path = self.write_spec(root, target_project=target_project)
+            repository = self.repository_module.AwsLambdaRepository(root=root)
+
+            result = repository.generate_lambda_project(spec_path=spec_path, execute=True)
+
+            self.assertEqual(result["status"], "written")
+            handler = target_project / "orders-webhook" / "src" / "handler.py"
+            self.assertTrue(handler.exists())
+            py_compile.compile(str(handler), doraise=True)
+            for item in result["written_files"]:
+                path = Path(item["path"]).resolve()
+                self.assertTrue(path.is_relative_to(target_project.resolve()), item["path"])
+
+    def test_generate_node_project_execute_writes_node_files(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            target_project = root / "target-project"
+            target_project.mkdir()
+            spec_path = self.write_spec(
+                root,
+                target_project=target_project,
+                runtime_family="nodejs",
+                runtime="nodejs20.x",
+                handler="handler.handler",
+                trigger="sqs",
+            )
+            repository = self.repository_module.AwsLambdaRepository(root=root)
+
+            result = repository.generate_lambda_project(spec_path=spec_path, execute=True)
+
+            self.assertEqual(result["status"], "written")
+            self.assertTrue((target_project / "orders-webhook" / "src" / "handler.js").exists())
+            self.assertTrue((target_project / "orders-webhook" / "tests" / "handler.test.js").exists())
+            self.assertTrue((target_project / "orders-webhook" / "package.json").exists())
+
+    def test_generate_lambda_project_blocks_overwrite_without_permission(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            target_project = root / "target-project"
+            target_project.mkdir()
+            spec_path = self.write_spec(root, target_project=target_project)
+            repository = self.repository_module.AwsLambdaRepository(root=root)
+            repository.generate_lambda_project(spec_path=spec_path, execute=True)
+
+            result = repository.generate_lambda_project(spec_path=spec_path, execute=True)
+
+            self.assertEqual(result["status"], "blocked")
+            self.assertEqual(result["reason"], "target_exists")
+
+    def test_package_lambda_dry_run_does_not_create_zip(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            project = self.write_project(root)
+            repository = self.repository_module.AwsLambdaRepository(root=root)
+
+            result = repository.package_lambda(project_path=project)
+
+            self.assertEqual(result["status"], "planned")
+            self.assertTrue(result["dry_run"])
+            self.assertFalse(Path(result["archive_path"]).exists())
+            self.assertIn("src/handler.py", result["files"])
+
+    def test_package_lambda_execute_creates_zip(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            project = self.write_project(root)
+            repository = self.repository_module.AwsLambdaRepository(root=root)
+
+            result = repository.package_lambda(project_path=project, execute=True)
+
+            self.assertEqual(result["status"], "written")
+            archive = Path(result["archive_path"])
+            self.assertTrue(archive.exists())
+            with zipfile.ZipFile(archive) as package:
+                names = set(package.namelist())
+            self.assertIn("src/handler.py", names)
+            self.assertNotIn(".env", names)
+
+    def test_deploy_lambda_plan_never_executes_real_deploy(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            spec_path = self.write_spec(root)
+            repository = self.repository_module.AwsLambdaRepository(root=root)
+
+            result = repository.deploy_lambda_plan(spec_path=spec_path)
+
+            self.assertEqual(result["status"], "ok")
+            self.assertFalse(result["deploy_real"])
+            self.assertEqual(result["write_policy"], "dry_run")
+            self.assertIn("sam deploy", " ".join(result["commands_to_review"]))
+            self.assertIn("sam deploy", result["blocked_actions"])
+
+    def test_plan_lambda_runner_is_executable_through_agent_cli(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            spec_path = self.write_spec(Path(tmpdir))
+
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    str(AGENT),
+                    "--json",
+                    "run",
+                    "aws-lambda-builder",
+                    "plan-lambda",
+                    "--spec",
+                    str(spec_path),
+                ],
+                cwd=ROOT,
+                check=False,
+                text=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                timeout=60,
+            )
+
+        self.assertEqual(result.returncode, 0, result.stderr or result.stdout)
+        payload = json.loads(result.stdout)
+        runner_payload = json.loads(payload["stdout"])
+        self.assertEqual(runner_payload["status"], "ok")
+        self.assertEqual(runner_payload["lambda"]["slug"], "orders-webhook")
+
+    def write_project(self, root: Path) -> Path:
+        project = root / "orders-webhook"
+        (project / "src").mkdir(parents=True)
+        (project / "events").mkdir()
+        (project / "src" / "handler.py").write_text("def lambda_handler(event, context):\n    return {}\n", encoding="utf-8")
+        (project / "events" / "api-gateway.json").write_text("{}", encoding="utf-8")
+        (project / ".env").write_text("SECRET=value\n", encoding="utf-8")
+        return project
+
+
+if __name__ == "__main__":
+    unittest.main()

package/runtime/agents/aws-operations-operator/agent.yaml

@@ -64,10 +64,22 @@ agent_surface:
     - ../../vendor/skills/CATALOG.md
 
 write_policy:
-  read_operations: auto
-  dry_run: default
-  execute_operations: requires_execute
-  production_operations: requires_explicit_environment
+  read_operations: read_only
+  dry_run: dry_run
+  execute_operations: confirm
+  production_operations: confirm
   destructive_operations: blocked_by_default
-  account_validation: required_for_execute
-  sensitive_payloads: redacted_in_artifacts
+  account_validation: confirm
+  sensitive_payloads: output_only
+
+routing:
+  anchors:
+    - aws
+    - cloudfront
+    - ecs
+    - eventbridge
+    - lambda
+    - sqs
+  intents:
+    - aws.operations
+  priority: 50

package/runtime/agents/aws-security-governance-auditor/agent.yaml

@@ -57,8 +57,20 @@ agent_surface:
     - ../../vendor/skills/CATALOG.md
 
 write_policy:
-  read_operations: auto
-  artifact_generation: auto
-  remediation_execution: unsupported
-  aws_mutations: unsupported
-  external_side_effects: unsupported
+  read_operations: read_only
+  artifact_generation: read_only
+  remediation_execution: blocked_by_default
+  aws_mutations: blocked_by_default
+  external_side_effects: blocked_by_default
+
+routing:
+  anchors:
+    - aws
+    - cloudtrail
+    - iam
+    - s3
+    - security
+    - seguranca
+  intents:
+    - aws.security.audit
+  priority: 50

package/runtime/agents/azure-devops-orchestrator/agent.yaml

@@ -48,9 +48,22 @@ agent_surface:
     - knowledge/policies.yaml
 
 write_policy:
-  read_operations: auto
+  read_operations: read_only
   comment_operations: confirm
   tag_operations: confirm
   assign_operations: confirm
   move_state_operations: confirm
-  bulk_operations: plan_then_confirm
+  bulk_operations: confirm
+
+routing:
+  anchors:
+    - azure
+    - board
+    - card
+    - devops
+    - item
+    - work
+    - workitem
+  intents:
+    - work-item.card
+  priority: 80

package/runtime/agents/azure-devops-orchestrator/capabilities/read-card/capability.yaml

@@ -32,4 +32,33 @@ integration:
     - ../../infra/integrations/azure/methods/get-work-item.yaml
     - ../../infra/integrations/azure/methods/get-work-item-comments.yaml
 
+runtime:
+  provider: azure-devops
+  source:
+    enabled: true
+    args:
+      project: --project
+      AZURE_DEVOPS_PROJECT: --project
+      fixture: --fixture
+    env:
+      org: AZURE_DEVOPS_ORG
+      organization: AZURE_DEVOPS_ORG
+      project: AZURE_DEVOPS_PROJECT
+      api_version: AZURE_DEVOPS_API_VERSION
+      AZURE_DEVOPS_ORG: AZURE_DEVOPS_ORG
+      AZURE_DEVOPS_PROJECT: AZURE_DEVOPS_PROJECT
+      AZURE_DEVOPS_API_VERSION: AZURE_DEVOPS_API_VERSION
+
 write_policy: read_only
+
+routing:
+  anchors:
+    - card
+    - tarefa
+    - work item
+    - workitem
+  intents:
+    - work-item.card.read
+  examples:
+    - analise o card 9900
+  priority: 90

package/runtime/agents/bpo-analyser/agent.yaml

@@ -60,5 +60,15 @@ agent_surface:
     - knowledge/policies.yaml
 
 write_policy:
-  read_operations: auto
-  mutation_operations: unsupported
+  read_operations: read_only
+  mutation_operations: blocked_by_default
+
+routing:
+  anchors:
+    - bpo
+    - cpf
+    - proposal
+    - proposta
+  intents:
+    - bpo.proposal.analysis
+  priority: 50

package/runtime/agents/bpo-analyser/knowledge/policies.yaml

@@ -13,8 +13,8 @@ integration_rules:
   default_timeout_seconds: 30
 
 write_policy:
-  read_operations: auto
-  mutation_operations: unsupported
+  read_operations: read_only
+  mutation_operations: blocked_by_default
 
 decision_policy:
   prefer_proposal_number: >

package/runtime/agents/data-scientist-analyst/agent.yaml

@@ -98,7 +98,19 @@ agent_surface:
     - knowledge/data-policies.md
 
 write_policy:
-  read_operations: auto
-  generated_artifacts: explicit_output_path
-  source_mutation: unsupported
-  external_side_effects: unsupported
+  read_operations: read_only
+  generated_artifacts: output_only
+  source_mutation: blocked_by_default
+  external_side_effects: blocked_by_default
+
+routing:
+  anchors:
+    - cohort
+    - dados
+    - data
+    - dataset
+    - estatistica
+    - modelo
+  intents:
+    - data.analysis
+  priority: 50

package/runtime/agents/data-scientist-analyst/capabilities/generate-data-report/capability.yaml

@@ -20,4 +20,4 @@ integration:
   repository: ../../infra/integrations/file-dataset/data_repository.py
   methods:
     - ../../infra/integrations/file-dataset/methods/generate-data-report.yaml
-write_policy: generated_artifacts_only
+write_policy: output_only

package/runtime/agents/data-scientist-analyst/capabilities/generate-reconciliation-report/capability.yaml

@@ -20,4 +20,4 @@ integration:
   repository: ../../infra/integrations/file-dataset/data_repository.py
   methods:
     - ../../infra/integrations/file-dataset/methods/generate-reconciliation-report.yaml
-write_policy: generated_artifacts_only
+write_policy: output_only

package/runtime/agents/data-scientist-analyst/capabilities/run-data-pipeline/capability.yaml

@@ -20,4 +20,4 @@ integration:
   repository: ../../infra/integrations/file-dataset/data_repository.py
   methods:
     - ../../infra/integrations/file-dataset/methods/run-data-pipeline.yaml
-write_policy: generated_artifacts_only
+write_policy: output_only

package/runtime/agents/data-scientist-analyst/infra/integrations/agent-bridge/methods/analyze-sql-source.yaml

@@ -1,4 +1,4 @@
 id: analyze-sql-source
 repository: cli-agent-bridge
 method: ai-devkit-run
-side_effects: delegated_read_only
+side_effects: read_only

package/runtime/agents/data-scientist-analyst/knowledge/policies.yaml

@@ -4,10 +4,10 @@
 # da spec agentic.
 
 write_policy:
-  read_operations: auto
-  generated_artifacts: explicit_output_path
-  source_mutation: unsupported
-  external_side_effects: unsupported
+  read_operations: read_only
+  generated_artifacts: output_only
+  source_mutation: blocked_by_default
+  external_side_effects: blocked_by_default
 
 pii_masking:
   mask_if_sensitive:

package/runtime/agents/data-scientist-analyst/knowledge/system.md

@@ -17,7 +17,7 @@ ESCOPO
   conciliacao de planilhas, relatorios e delegacao de SQL read-only.
 - Nao pode: alterar a fonte, escrever em bancos/planilhas/sistemas externos,
   rodar acoes com efeito colateral. Tudo e somente leitura
-  (write_policy.source_mutation: unsupported; external_side_effects: unsupported).
+  (write_policy.source_mutation: blocked_by_default; external_side_effects: blocked_by_default).
 
 PRINCIPIOS DE DECISAO
 1. Profile antes de concluir. Sempre rode profile-dataset (ou ja tenha o JSON)

package/runtime/agents/data-scientist-analyst/tests/test_runners.py

@@ -1439,7 +1439,7 @@ class DataScientistAnalystRunnersTest(unittest.TestCase):
         self.assertIn("write_policy", policies)
         self.assertIn("pii_masking", policies)
         self.assertIn("decision_rules", policies)
-        self.assertEqual(policies["write_policy"]["source_mutation"], "unsupported")
+        self.assertEqual(policies["write_policy"]["source_mutation"], "blocked_by_default")
         masked = policies["pii_masking"]["mask_if_sensitive"]
         for field in ["cpf", "cnpj", "email", "telefone", "nome"]:
             self.assertIn(field, masked, f"pii_masking must cover '{field}'")