@intentius/chant 0.52.1 → 0.53.0

package/src/agents/importer.ts

@@ -0,0 +1,49 @@
+/**
+ * The seam between neutral agent-config discovery and a lexicon's vocabulary.
+ *
+ * `discover.ts` deliberately knows nothing about chant resources — it reads
+ * five harnesses' config dialects and stops. Turning an {@link AgentConfigSite}
+ * into resources is a statement about a *target* (fountain's `Agent` and
+ * `Environment`, today), and that judgement belongs to the lexicon that owns
+ * those types, exactly as `templateParser()` puts CloudFormation's JSON
+ * vocabulary in the aws lexicon rather than in core.
+ *
+ * So a lexicon that can express local agent configuration implements
+ * {@link AgentConfigImporter} and returns it from
+ * `LexiconPlugin.agentConfigImporter()`. `chant import --agents` loads the
+ * plugin, hands it the scan, and pipes the resulting IR through the same
+ * `templateGenerator()` every other import path uses.
+ */
+
+import type { TemplateIR } from "../import/parser";
+import type { AgentConfigSite } from "./types";
+
+/** A site the importer could not express, and why. */
+export interface SkippedSite {
+  siteId: string;
+  reason: string;
+}
+
+/**
+ * The result of re-expressing a scan.
+ *
+ * The three report arrays exist because this conversion is lossy in ways the
+ * user must be told about: a site that couldn't be mapped, a required property
+ * that had to be defaulted, and a secret that was rewritten rather than copied
+ * are all things a reader would otherwise discover only by diffing the output
+ * against their own config.
+ */
+export interface AgentImportOutcome {
+  ir: TemplateIR;
+  /** Sites that could not be re-expressed in this lexicon's vocabulary. */
+  skipped: SkippedSite[];
+  /** Site ids where a required property was filled with a default rather than a discovered value. */
+  unmappedModel: string[];
+  /** Site ids where a literal credential was replaced with an environment reference. */
+  redactedSecrets: string[];
+}
+
+/** Converts discovered agent configuration into a lexicon's resource IR. */
+export interface AgentConfigImporter {
+  toTemplateIR(sites: AgentConfigSite[]): AgentImportOutcome;
+}

package/src/agents/index.ts

@@ -0,0 +1,29 @@
+/**
+ * Agent-configuration discovery and checks.
+ *
+ * Finds the agent configs on a machine (`discover.ts`), judges them
+ * (`checks.ts`), and normalizes both onto one vendor-neutral model
+ * (`types.ts`). The two consumers are `chant audit --agents`, which reports on
+ * what it finds, and `chant import --agents`, which re-expresses it as chant
+ * code via a lexicon's IR mapper.
+ */
+
+export type {
+  AgentConfigSite,
+  AgentFinding,
+  AgentRuntime,
+  AgentScanResult,
+  AgentScope,
+  CommandDecl,
+  InstructionFile,
+  McpServerDecl,
+  McpTransport,
+  PermissionConfig,
+  PluginDecl,
+  SkillDecl,
+  SkillOrigin,
+  SubagentDecl,
+} from "./types";
+export { AGENT_RUNTIMES, AGENT_SCOPES } from "./types";
+export { scanAgentConfigs, normalizeMcpServers, frontmatter, systemSettingsPaths, unscannedProjectCount, type ScanOptions } from "./discover";
+export { checkAgentConfigs, AGENT_RULE_IDS } from "./checks";

package/src/agents/types.ts

@@ -0,0 +1,207 @@
+/**
+ * The normalized model for an agent configuration found on a machine.
+ *
+ * Five harnesses (claude, codex, gemini, opencode, cursor) each spell the same
+ * four ideas differently — standing instructions, tool servers, reusable
+ * skills, and ambient settings. `discover.ts` reads each harness's own dialect
+ * and lands here; everything downstream (`checks.ts`, the report, the fountain
+ * IR mapping) reads only this shape and never a vendor file format again.
+ *
+ * The `AgentConfigSite` boundary is deliberately "one config that governs one
+ * root, for one runtime" rather than "one file". A single Claude Code site is
+ * assembled from `CLAUDE.md` + `settings.json` + `settings.local.json` +
+ * `mcp.json` + `~/.claude.json` + a `skills/` tree — six files that are only
+ * meaningful together, and that the agent itself experiences as one merged
+ * configuration. `sources` keeps the receipts so a finding can point at the
+ * actual file the reader has to edit.
+ */
+
+/**
+ * Which agent harness a config belongs to. The first four are exactly
+ * fountain's `Agent.runtime` enum, so they re-express losslessly; `cursor` is
+ * discovered and reported but has no fountain runtime to map onto (see
+ * `MAPPABLE_RUNTIMES` in the fountain import mapper).
+ */
+export type AgentRuntime = "claude" | "codex" | "gemini" | "opencode" | "cursor";
+
+/**
+ * Blast radius of a config, in the order harnesses merge them (later wins).
+ *
+ * - `system` — machine-wide policy, typically administrator-installed and not
+ *   user-editable (Claude Code's `managed-settings.json`).
+ * - `user` — the home directory. Applies to *every* project the user opens,
+ *   which is what makes it the highest-leverage scope to audit.
+ * - `project` — checked into (or sitting beside) a repo. Narrowest scope, but
+ *   the one most likely to arrive from someone else.
+ */
+export type AgentScope = "system" | "user" | "project";
+
+export const AGENT_SCOPES: readonly AgentScope[] = ["system", "user", "project"] as const;
+export const AGENT_RUNTIMES: readonly AgentRuntime[] = ["claude", "codex", "gemini", "opencode", "cursor"] as const;
+
+/** A standing-instructions file (CLAUDE.md, AGENTS.md, GEMINI.md, .cursorrules). */
+export interface InstructionFile {
+  /** Absolute path on disk. */
+  path: string;
+  /** File contents. Read in full — these become fountain's `Agent.system`. */
+  content: string;
+  bytes: number;
+}
+
+/** How an MCP server is reached. `unknown` when the declaration has neither a command nor a URL. */
+export type McpTransport = "stdio" | "http" | "sse" | "unknown";
+
+/** One MCP server declaration, normalized across the several files that can declare one. */
+export interface McpServerDecl {
+  name: string;
+  transport: McpTransport;
+  /** The file this declaration was read from. */
+  source: string;
+  /** stdio: the executable. */
+  command?: string;
+  /** stdio: argv after the executable. */
+  args?: string[];
+  /** http/sse: the endpoint. */
+  url?: string;
+  /** Environment handed to the server process. Values are kept verbatim — `checks.ts` is what decides whether one looks like a literal credential. */
+  env?: Record<string, string>;
+  /** Extra keys the harness accepted that this model doesn't name (headers, timeouts, …). */
+  extra?: Record<string, unknown>;
+}
+
+/**
+ * Where a skill came from. This distinction is the whole point of the skill
+ * checks: a `local` skill is text the user can read in their own filesystem,
+ * while `plugin`/`marketplace` skills are fetched from a remote and can change
+ * under the user without any edit to their machine.
+ */
+export type SkillOrigin = "local" | "plugin" | "marketplace";
+
+/** One skill available to the agent. */
+export interface SkillDecl {
+  name: string;
+  origin: SkillOrigin;
+  /** Absolute path to the skill directory or SKILL.md, when it exists on disk. */
+  path?: string;
+  /** Remote source (`owner/repo`, a URL) for plugin/marketplace skills. */
+  source?: string;
+  /** Version pin on `source`: a tag, branch, or sha. Absence is what AGT004 flags. */
+  ref?: string;
+  /** SKILL.md body, when read. Becomes fountain's inline `{name, content}` skill form. */
+  content?: string;
+  /** The skill's own frontmatter `description`, used for the fountain `description`. */
+  description?: string;
+}
+
+/** A subagent / custom agent definition (`.claude/agents/*.md`). */
+export interface SubagentDecl {
+  name: string;
+  path: string;
+  description?: string;
+  /** Tool allowlist declared in frontmatter, if any. */
+  tools?: string;
+  model?: string;
+}
+
+/** A slash command definition (`.claude/commands/*.md`, `~/.codex/prompts`). */
+export interface CommandDecl {
+  name: string;
+  path: string;
+  description?: string;
+}
+
+/** An installed plugin — a bundle that can inject skills, commands, and MCP servers at once. */
+export interface PluginDecl {
+  name: string;
+  /** Marketplace or repo the plugin was installed from. */
+  marketplace?: string;
+  /** Version pin, when the install recorded one. */
+  ref?: string;
+  enabled: boolean;
+  /**
+   * True when the plugin tracks a remote the user does not control.
+   *
+   * The pinning checks turn on this: a plugin vendored from a local directory
+   * cannot change underneath the user, so "pin it" is not advice that applies.
+   * Harnesses ship bundled plugins from local paths (codex's
+   * `source_type = "local"`), and reporting those as unpinned supply chain is
+   * noise that trains the reader to skip the rule.
+   */
+  remote: boolean;
+}
+
+/** Tool-permission configuration, normalized from a harness's own settings shape. */
+export interface PermissionConfig {
+  allow?: string[];
+  deny?: string[];
+  ask?: string[];
+  defaultMode?: string;
+  /** True when the config disables a confirmation prompt outright. */
+  bypassesPrompts?: boolean;
+}
+
+/**
+ * One complete agent configuration governing one root, for one runtime.
+ *
+ * Assembled from every file at that scope the harness would merge together —
+ * see the module docstring for why the file is not the unit.
+ */
+export interface AgentConfigSite {
+  /** Stable slug, unique within a scan: `user-claude`, `project-claude-chant`. Becomes the fountain resource name. */
+  id: string;
+  scope: AgentScope;
+  runtime: AgentRuntime;
+  /** Directory this configuration governs. For `user` scope, the home directory. */
+  root: string;
+  /** Every file that contributed, absolute. A site with no sources is never emitted. */
+  sources: string[];
+  instructions: InstructionFile[];
+  mcpServers: McpServerDecl[];
+  skills: SkillDecl[];
+  subagents: SubagentDecl[];
+  commands: CommandDecl[];
+  plugins: PluginDecl[];
+  /** Environment variables the harness injects into every session. */
+  env: Record<string, string>;
+  permissions?: PermissionConfig;
+  /** Default model pinned by the config, when set. */
+  model?: string;
+  /**
+   * Raw merged settings, kept so a check can interrogate a key this model
+   * doesn't name without a schema change. Not used for codegen.
+   */
+  settings: Record<string, unknown>;
+}
+
+/** Everything one scan found, plus what it couldn't read. */
+export interface AgentScanResult {
+  sites: AgentConfigSite[];
+  /** Locations probed and found absent — useful for "is it really not configured, or did I not look?" */
+  probed: string[];
+  /** Paths that existed but could not be read or parsed, with the reason. */
+  unreadable: Array<{ path: string; reason: string }>;
+  /**
+   * Every MCP declaration each site saw, keyed by site id — including names
+   * that lost the first-wins merge and so do not appear in
+   * `AgentConfigSite.mcpServers`. Diagnostic data for the shadowing check
+   * (AGT007), kept beside the sites rather than on them because it describes
+   * the *discovery*, not the configuration being re-expressed.
+   */
+  declarations: Record<string, McpServerDecl[]>;
+}
+
+/** A finding raised by an agent-config check against a discovered site. */
+export interface AgentFinding {
+  /** Catalog id, e.g. `AGT001`. */
+  checkId: string;
+  severity: "error" | "warning" | "info";
+  message: string;
+  /** The specific file a reader has to open to fix this. */
+  file: string;
+  /** The site the finding belongs to. */
+  siteId: string;
+  scope: AgentScope;
+  runtime: AgentRuntime;
+  /** The named thing within the site (an MCP server name, a skill name). */
+  entity?: string;
+}

package/src/audit/catalog.ts

@@ -127,6 +127,14 @@ export const CF_STATIC_ASSETS: Authority = {
   name: "Cloudflare Workers — Static assets",
   url: "https://developers.cloudflare.com/workers/static-assets/",
 };
+export const CWE_HARDCODED_CREDS: Authority = {
+  name: "CWE-798 — Use of Hard-coded Credentials",
+  url: "https://cwe.mitre.org/data/definitions/798.html",
+};
+export const CWE_CLEARTEXT: Authority = {
+  name: "CWE-319 — Cleartext Transmission of Sensitive Information",
+  url: "https://cwe.mitre.org/data/definitions/319.html",
+};
 
 function meta(
   id: string,
@@ -149,6 +157,21 @@ const R = "report-only" as const;
 const D = "deterministic" as const;
 const G = "guidance" as const;
 
+/**
+ * An AGT (agent-configuration) rule. Unlike every other family in the catalog
+ * these do not run against emitted YAML — they run against the agent config
+ * discovered on a machine (`packages/core/src/agents/`), so `yamlBased` is
+ * false: feeding a workflow file to the auditor will never produce one.
+ *
+ * All eight are `guidance`. There is no safe mechanical fix for any of them —
+ * pinning someone's MCP server picks a version on their behalf, and narrowing a
+ * permission grant requires knowing which commands they actually run.
+ */
+function agentMeta(id: string, tier: Tier, title: string, remediation: string, authority?: Authority[]): RuleMeta {
+  const category: Category = authority && authority.length > 0 ? "security" : RULE_CATEGORY[id] ?? "best-practice";
+  return { id, tier, fixKind: G, category, title, remediation, authority, yamlBased: false };
+}
+
 /**
  * Finding category per rule (#415). Curated: security rules are those that
  * cite an authority or guard an exposure; correctness rules flag structural
@@ -174,6 +197,17 @@ export const RULE_CATEGORY: Record<string, Category> = {
   WRG004: "security",
   WRG005: "security",
   WRG006: "security",
+  // AGT — agent configuration (`chant audit --agents`). Core-owned like COR/EXT:
+  // these run against the machine's own agent config, not against any one
+  // lexicon's emitted output, so no lexicon ships them.
+  AGT001: "security",
+  AGT002: "security",
+  AGT003: "security",
+  AGT004: "security",
+  AGT005: "security",
+  AGT006: "best-practice",
+  AGT007: "correctness",
+  AGT008: "best-practice",
 };
 
 /**
@@ -181,7 +215,8 @@ export const RULE_CATEGORY: Record<string, Category> = {
  * CloudFormation ids (COR/EXT) that aren't owned by a single lexicon. Every
  * per-provider block moved to its lexicon's `auditCatalog()` (#687): WAW→aws,
  * WGC→gcp, AZR→azure, DKRD→docker, WK8/ARGO→k8s, WHM→helm, GHA→github,
- * WGL→gitlab, WFJ→forgejo. `resolveAuditCatalog` merges those over this map.
+ * WGL→gitlab, WFJ→forgejo. `resolveAuditCatalog` merges those over this map,
+ * alongside the lexicon-independent SEC/WRG/AGT families core owns outright.
  */
 export const RULE_CATALOG: Record<string, RuleMeta> = {
   COR020: meta("COR020", M, G, "Circular resource dependency", "Break the dependency cycle between resources."),
@@ -211,6 +246,60 @@ export const RULE_CATALOG: Record<string, RuleMeta> = {
   WRG004: meta("WRG004", M, G, "Unscoped wildcard route", "Scope the route pattern to the intended zone (e.g. \"example.com/*\") instead of a bare \"*\" or \"*/*\" that matches every zone on the account.", [CF_ROUTES]),
   WRG005: meta("WRG005", M, G, "Non-production environment shares a data store with production", "Give the non-production environment its own KV namespace/R2 bucket/D1 database id instead of reusing production's.", [CF_ENVIRONMENTS]),
   WRG006: meta("WRG006", M, G, "Static assets served from the project root", "Point [site].bucket / [assets].directory at a dedicated public output folder, not the project root, so non-public files (config, source maps, .git) aren't served.", [CF_STATIC_ASSETS]),
+
+  // ── Agent configuration (`chant audit --agents`) ──────────────────
+  AGT001: agentMeta(
+    "AGT001",
+    M,
+    "MCP server runs an unpinned package",
+    "Pin the package spec to an exact version (`server@1.2.3`), so a new upstream release can't execute on this machine unreviewed.",
+    [SCORECARD_PINNED],
+  ),
+  AGT002: agentMeta(
+    "AGT002",
+    M,
+    "Literal credential in agent config",
+    "Replace the value with an environment reference (`${TOKEN}`) and keep the secret in a secret store — agent config files sync, back up, and get shared.",
+    [CWE_HARDCODED_CREDS],
+  ),
+  AGT003: agentMeta(
+    "AGT003",
+    M,
+    "MCP server reached over cleartext HTTP",
+    "Use an https:// endpoint. Tool arguments and results — including data the agent read locally — otherwise cross the network in the clear.",
+    [CWE_CLEARTEXT],
+  ),
+  AGT004: agentMeta(
+    "AGT004",
+    M,
+    "Remote skill or plugin is unpinned",
+    "Pin the source to a tag or commit sha, so the instructions the agent follows can't change upstream without a local edit.",
+    [SCORECARD_PINNED],
+  ),
+  AGT005: agentMeta(
+    "AGT005",
+    M,
+    "Tool permission granted without constraint",
+    "Scope the grant to the specific commands you run (`Bash(git status:*)`), and re-enable the confirmation prompt for dangerous operations.",
+  ),
+  AGT006: agentMeta(
+    "AGT006",
+    R,
+    "User-scope config applies to every project",
+    "Move project-specific instructions, MCP servers, and skills to that project's own config so they don't follow you into unrelated repos.",
+  ),
+  AGT007: agentMeta(
+    "AGT007",
+    R,
+    "MCP server declared in multiple files",
+    "Delete the shadowed declarations. The harness silently picks one, so the file you read may not be the one that decides what runs.",
+  ),
+  AGT008: agentMeta(
+    "AGT008",
+    R,
+    "Instruction file exceeds the attention budget",
+    "Move situational guidance into skills that load on demand, so the always-on instructions stay short enough to be followed reliably.",
+  ),
 };
 
 /**

package/src/audit/report.ts

@@ -39,6 +39,14 @@ export interface RenderOptions {
   notes?: string[];
   /** Resolved audit catalog (core static + active lexicons' contributions, #687). Defaults to core's static catalog. */
   catalog?: Record<string, RuleMeta>;
+  /**
+   * Markdown heading text and level for the report's own title. `chant audit
+   * --agents` embeds this report under its inventory, so it renders as a
+   * level-2 "Findings" section rather than a second `# chant audit` H1 in a
+   * document that already has one.
+   */
+  title?: string;
+  headingLevel?: 1 | 2;
 }
 
 function escapeCell(s: string): string {
@@ -96,7 +104,7 @@ export function renderMarkdown(findings: AuditFinding[], opts: RenderOptions = {
   const model = buildReportModel(findings, opts);
   const { counts } = model;
 
-  const lines: string[] = ["# chant audit"];
+  const lines: string[] = [`${"#".repeat(opts.headingLevel ?? 1)} ${opts.title ?? "chant audit"}`];
   if (opts.target) lines.push("", `Target: ${opts.target}`);
   lines.push("");
   for (const note of opts.notes ?? []) lines.push(`> Note: ${note}`, "");

package/src/audit/rules-doc.ts

@@ -23,6 +23,12 @@ const GROUPS: Array<{ heading: string; prefixes: string[]; blurb: string }> = [
   { heading: "fountain (FTN)", prefixes: ["FTN"], blurb: "Run against fountain manifests (`apiVersion: fountain.dev/v1`) — standalone `fountain apply` YAML is parsed back into the entity graph, so the same rules fire on `chant build` and `chant audit`." },
   { heading: "Secrets & credentials (SEC)", prefixes: ["SEC"], blurb: "Lexicon-independent — scans the raw text of every scanned file for likely credentials, regardless of which audit lexicons are installed. Matched values are always redacted; see [suppressing false positives](/chant/cli/audit/#suppressing-a-secrets-finding)." },
   { heading: "Wrangler config (WRG)", prefixes: ["WRG"], blurb: "Lexicon-independent, audit-only (#446) — scans `wrangler.toml`, Cloudflare Workers' native deploy config, which the engine cannot otherwise parse (it is not YAML/JSON). No authoring surface: chant does not write Wrangler config, it only reads it for these checks." },
+  {
+    heading: "Agent configuration (AGT)",
+    prefixes: ["AGT"],
+    blurb:
+      "Run by `chant audit --agents` against the agent configuration on a machine — instruction files, MCP servers, skills, plugins, and permissions at system, user, and project scope. Unlike every other family here, these do not fire on repository YAML.",
+  },
 ];
 
 /**

package/src/cdk/__fixtures__/cdk.out/AppStack.template.json

@@ -0,0 +1,171 @@
+{
+  "Parameters": {
+    "EnvName": {
+      "Type": "String",
+      "Default": "dev"
+    },
+    "BootstrapVersion": {
+      "Type": "AWS::SSM::Parameter::Value<String>",
+      "Default": "/cdk-bootstrap/hnb659fds/version",
+      "Description": "Version of the CDK Bootstrap resources in this environment"
+    }
+  },
+  "Conditions": {
+    "IsProd": { "Fn::Equals": [{ "Ref": "EnvName" }, "prod"] }
+  },
+  "Resources": {
+    "ApiQueue4A6E9832": {
+      "Type": "AWS::SQS::Queue",
+      "Properties": {
+        "VisibilityTimeout": 300
+      },
+      "UpdateReplacePolicy": "Delete",
+      "DeletionPolicy": "Delete",
+      "Metadata": {
+        "aws:cdk:path": "AppStack/Api/Queue/Resource"
+      }
+    },
+    "ApiTopic1B2C3D4E": {
+      "Type": "AWS::SNS::Topic",
+      "Properties": {
+        "DisplayName": "api-events"
+      },
+      "Metadata": {
+        "aws:cdk:path": "AppStack/Api/Topic/Resource"
+      }
+    },
+    "ApiTopicQueueSubscriptionAA11BB22": {
+      "Type": "AWS::SNS::Subscription",
+      "Properties": {
+        "Protocol": "sqs",
+        "TopicArn": { "Ref": "ApiTopic1B2C3D4E" },
+        "Endpoint": { "Fn::GetAtt": ["ApiQueue4A6E9832", "Arn"] }
+      },
+      "Metadata": {
+        "aws:cdk:path": "AppStack/Api/Topic/QueueSubscription/Resource"
+      }
+    },
+    "HandlerServiceRoleFCDC14AE": {
+      "Type": "AWS::IAM::Role",
+      "Properties": {
+        "AssumeRolePolicyDocument": {
+          "Statement": [
+            {
+              "Action": "sts:AssumeRole",
+              "Effect": "Allow",
+              "Principal": { "Service": "lambda.amazonaws.com" }
+            }
+          ],
+          "Version": "2012-10-17"
+        }
+      },
+      "Metadata": {
+        "aws:cdk:path": "AppStack/Handler/ServiceRole/Resource"
+      }
+    },
+    "HandlerServiceRoleDefaultPolicy4C43A1F9": {
+      "Type": "AWS::IAM::Policy",
+      "Properties": {
+        "PolicyDocument": {
+          "Statement": [
+            {
+              "Action": ["s3:GetObject", "s3:PutObject"],
+              "Effect": "Allow",
+              "Resource": {
+                "Fn::Join": [
+                  "",
+                  [
+                    { "Fn::ImportValue": "DataStack:ExportsOutputFnGetAttAssets675B7A57ArnE0B2A4A8" },
+                    "/*"
+                  ]
+                ]
+              }
+            }
+          ],
+          "Version": "2012-10-17"
+        },
+        "PolicyName": "HandlerServiceRoleDefaultPolicy4C43A1F9",
+        "Roles": [{ "Ref": "HandlerServiceRoleFCDC14AE" }]
+      },
+      "Metadata": {
+        "aws:cdk:path": "AppStack/Handler/ServiceRole/DefaultPolicy/Resource"
+      }
+    },
+    "Handler886CB40B": {
+      "Type": "AWS::Lambda::Function",
+      "Properties": {
+        "Code": {
+          "S3Bucket": { "Fn::Sub": "cdk-hnb659fds-assets-${AWS::AccountId}-${AWS::Region}" },
+          "S3Key": "9f8e7d6c5b4a39281706f5e4d3c2b1a09f8e7d6c5b4a39281706f5e4d3c2b1a0.zip"
+        },
+        "Environment": {
+          "Variables": {
+            "QUEUE_URL": { "Ref": "ApiQueue4A6E9832" }
+          }
+        },
+        "Handler": "index.handler",
+        "Role": { "Fn::GetAtt": ["HandlerServiceRoleFCDC14AE", "Arn"] },
+        "Runtime": "nodejs20.x"
+      },
+      "DependsOn": ["HandlerServiceRoleDefaultPolicy4C43A1F9", "HandlerServiceRoleFCDC14AE"],
+      "Metadata": {
+        "aws:cdk:path": "AppStack/Handler/Resource",
+        "aws:asset:path": "asset.9f8e7d6c5b4a39281706f5e4d3c2b1a0",
+        "aws:asset:is-bundled": false,
+        "aws:asset:property": "Code"
+      }
+    },
+    "LegacyBucket": {
+      "Type": "AWS::S3::Bucket",
+      "Condition": "IsProd",
+      "Properties": {
+        "BucketName": { "Fn::Sub": "legacy-${EnvName}-archive" }
+      },
+      "UpdateReplacePolicy": "Retain",
+      "DeletionPolicy": "Retain",
+      "Metadata": {
+        "aws:cdk:path": "AppStack/Legacy"
+      }
+    },
+    "ReportsNestedStackReportsNestedStackResource7B21D4C6": {
+      "Type": "AWS::CloudFormation::Stack",
+      "Properties": {
+        "TemplateURL": {
+          "Fn::Join": [
+            "",
+            [
+              "https://s3.",
+              { "Ref": "AWS::Region" },
+              ".",
+              { "Ref": "AWS::URLSuffix" },
+              "/cdk-hnb659fds-assets-",
+              { "Ref": "AWS::AccountId" },
+              "-",
+              { "Ref": "AWS::Region" },
+              "/1a2b3c4d5e6f70819a2b3c4d5e6f70819a2b3c4d5e6f70819a2b3c4d5e6f7081.json"
+            ]
+          ]
+        }
+      },
+      "UpdateReplacePolicy": "Delete",
+      "DeletionPolicy": "Delete",
+      "Metadata": {
+        "aws:cdk:path": "AppStack/Reports.NestedStack/Reports.NestedStackResource"
+      }
+    },
+    "CDKMetadata": {
+      "Type": "AWS::CDK::Metadata",
+      "Properties": {
+        "Analytics": "v2:deflate64:H4sIAAAAAAAA/y2K0QqAIAwAv8V3XVEE9V4fEEQfIGtJmDrYVoT4740ed3fY4wr7BgtCvIYuBl+w7gLuoIm2y9lgAWJv6TylOUYVXpLK5x0Ipp98yRz5Uqz+MvzQZlvibDpsMK1SUteYWvwNyxu2AlgAAAA="
+      },
+      "Metadata": {
+        "aws:cdk:path": "AppStack/CDKMetadata/Default"
+      }
+    }
+  },
+  "Outputs": {
+    "QueueUrl": {
+      "Value": { "Ref": "ApiQueue4A6E9832" }
+    }
+  }
+}