@codyswann/lisa 2.280.0 → 2.282.0

package/all/copy-contents/gitignore

@@ -215,6 +215,8 @@ expo-env.d.ts
 .lisa/verification-status.json
 # Latest Health v1 result is local runtime state, never project configuration.
 .lisa/health/latest.json
+# Freshness-bound standards proof is local runtime evidence, not knowledge.
+.lisa/standards/latest.json
 
 # Automation run outcomes — local scheduler observations read by
 # /lisa:automation-status. Runbooks are project knowledge; run records are not.

package/dist/cli/doctor-readiness-capabilities.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The capabilities/tools readiness producer (PRD #1739, #1896).
+ *
+ * Dimension 2 of the `readiness-rubric` asks whether every tool the work needs
+ * is provably *reachable*, not merely installed. The `tool-access-gate` names
+ * the anti-pattern explicitly: a binary on `PATH`, a dependency in a manifest,
+ * or a configured MCP server proves that something was declared, never that a
+ * request through it succeeds. Reachability is established by a live read-only
+ * probe against the real system, and nothing an offline file read can see is a
+ * substitute for one.
+ *
+ * So this dimension has no offline evidence to gather and no blocker to stand.
+ * What it has is an obligation to say so: a blank dimension reads as "nothing to
+ * report" when it actually means "never looked" (#1898), and a presence-based
+ * PASS would be worse still — it would report the anti-pattern as proof. The
+ * producer therefore renders one reasoned SKIP, every time, naming the live
+ * probe it did not run.
+ * @module cli/doctor-readiness-capabilities
+ */
+import type { ReadinessDimensionRecord } from "./doctor-readiness-types.js";
+/** The capabilities/tools readiness dimension id (readiness-rubric, RRR-1). */
+export declare const CAPABILITIES_TOOLS_DIMENSION_ID = "capabilities-tools";
+/**
+ * Assess the capabilities/tools dimension. Always a reasoned SKIP: the question
+ * is not offline-answerable, so the honest answer is a stated non-answer. The
+ * record names no `blocker`, so it can never stand one up, and the `root`
+ * argument is accepted only to satisfy the shared producer signature — reading
+ * it would be the presence anti-pattern the rule forbids.
+ * @param _root - Project root (deliberately unread)
+ * @returns The capabilities/tools dimension record
+ */
+export declare function assessCapabilitiesToolsDimension(_root: string): Promise<ReadinessDimensionRecord>;
+//# sourceMappingURL=doctor-readiness-capabilities.d.ts.map

package/dist/cli/doctor-readiness-capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor-readiness-capabilities.d.ts","sourceRoot":"","sources":["../../src/cli/doctor-readiness-capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AAE5E,+EAA+E;AAC/E,eAAO,MAAM,+BAA+B,uBAAuB,CAAC;AAWpE;;;;;;;;GAQG;AACH,wBAAsB,gCAAgC,CACpD,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,wBAAwB,CAAC,CAMnC"}

package/dist/cli/doctor-readiness-capabilities.js

@@ -0,0 +1,26 @@
+/** The capabilities/tools readiness dimension id (readiness-rubric, RRR-1). */
+export const CAPABILITIES_TOOLS_DIMENSION_ID = "capabilities-tools";
+/** The stated reason this dimension is never assessed by an offline read. */
+const CAPABILITIES_SKIP_REASON = "Tool reachability requires a live read-only probe against the real system " +
+    "and cannot be established from an offline read. The `tool-access-gate` rule " +
+    "names presence — a binary on `PATH`, a dependency in a manifest, a " +
+    "configured MCP server — as the anti-pattern: it proves a tool was declared, " +
+    "never that a request through it succeeds. This dimension was therefore " +
+    "deliberately not assessed rather than answered from presence.";
+/**
+ * Assess the capabilities/tools dimension. Always a reasoned SKIP: the question
+ * is not offline-answerable, so the honest answer is a stated non-answer. The
+ * record names no `blocker`, so it can never stand one up, and the `root`
+ * argument is accepted only to satisfy the shared producer signature — reading
+ * it would be the presence anti-pattern the rule forbids.
+ * @param _root - Project root (deliberately unread)
+ * @returns The capabilities/tools dimension record
+ */
+export async function assessCapabilitiesToolsDimension(_root) {
+    return await Promise.resolve({
+        id: CAPABILITIES_TOOLS_DIMENSION_ID,
+        status: "SKIP",
+        findings: [{ reason: CAPABILITIES_SKIP_REASON, skip: true }],
+    });
+}
+//# sourceMappingURL=doctor-readiness-capabilities.js.map

package/dist/cli/doctor-readiness-capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor-readiness-capabilities.js","sourceRoot":"","sources":["../../src/cli/doctor-readiness-capabilities.ts"],"names":[],"mappings":"AAqBA,+EAA+E;AAC/E,MAAM,CAAC,MAAM,+BAA+B,GAAG,oBAAoB,CAAC;AAEpE,6EAA6E;AAC7E,MAAM,wBAAwB,GAC5B,4EAA4E;IAC5E,8EAA8E;IAC9E,qEAAqE;IACrE,8EAA8E;IAC9E,yEAAyE;IACzE,+DAA+D,CAAC;AAElE;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,gCAAgC,CACpD,KAAa;IAEb,OAAO,MAAM,OAAO,CAAC,OAAO,CAAC;QAC3B,EAAE,EAAE,+BAA+B;QACnC,MAAM,EAAE,MAAM;QACd,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,wBAAwB,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;KAC7D,CAAC,CAAC;AACL,CAAC"}

package/dist/cli/doctor-readiness-domain.d.ts

@@ -0,0 +1,17 @@
+import type { ReadinessDimensionRecord } from "./doctor-readiness-types.js";
+import { type ParsedWorkflow } from "./doctor-readiness-workflows.js";
+/** The domain-ownership readiness dimension id (readiness-rubric, RRR-1). */
+export declare const DOMAIN_OWNERSHIP_DIMENSION_ID = "domain-ownership";
+/**
+ * Assess the domain-ownership dimension: B1, "a realistic path causes silent
+ * data loss". Offline by construction — it reads only the repository's declared
+ * workflows — and deliberately conservative: it stands B1 only when a workflow
+ * file alone proves an irreversible data-destroying command runs unattended,
+ * ungated, and with no way back, and renders a stated-reason SKIP in every other
+ * case, including the clean one.
+ * @param root - Project root to assess
+ * @param parsedWorkflows - Pre-parsed workflows (default: parse `root`)
+ * @returns The domain-ownership dimension record
+ */
+export declare function assessDomainOwnershipDimension(root: string, parsedWorkflows?: readonly ParsedWorkflow[]): Promise<ReadinessDimensionRecord>;
+//# sourceMappingURL=doctor-readiness-domain.d.ts.map

package/dist/cli/doctor-readiness-domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor-readiness-domain.d.ts","sourceRoot":"","sources":["../../src/cli/doctor-readiness-domain.ts"],"names":[],"mappings":"AAqCA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AAC5E,OAAO,EACL,KAAK,cAAc,EAGpB,MAAM,iCAAiC,CAAC;AAEzC,6EAA6E;AAC7E,eAAO,MAAM,6BAA6B,qBAAqB,CAAC;AAiKhE;;;;;;;;;;GAUG;AACH,wBAAsB,8BAA8B,CAClD,IAAI,EAAE,MAAM,EACZ,eAAe,CAAC,EAAE,SAAS,cAAc,EAAE,GAC1C,OAAO,CAAC,wBAAwB,CAAC,CAyBnC"}

package/dist/cli/doctor-readiness-domain.js

@@ -0,0 +1,197 @@
+/**
+ * The domain-ownership readiness producer — ship blocker B1 (PRD #1739, #1896).
+ *
+ * Dimension 3 of the `readiness-rubric` asks whether the business rules,
+ * glossary, and danger zones are owned and written down. B1 asks the sharpest
+ * consequence of getting that wrong: does a realistic path destroy or corrupt
+ * data with no error surfaced and no way back?
+ *
+ * That question is the hardest one in the rubric to answer honestly offline, and
+ * getting it wrong is expensive in exactly one direction. A standing blocker
+ * flips the whole repository to `NOT_READY` regardless of this dimension's
+ * status — `WARN` is a confidence signal to a human reader, never a softener —
+ * so a false B1 on an ordinary brownfield repository would destroy the trust
+ * this entire feature exists to build. Three disciplines follow:
+ *
+ * 1. **Only an unambiguous, automated, ungated, unrecoverable destruction of
+ *    data stands B1.** The command must irreversibly destroy *data* (not build
+ *    output), inside a job an automated trigger reaches, with no `if:`, no
+ *    `environment:`, no backup step beside it, and no checked-in runbook.
+ * 2. **Presence of a destructive surface is never a violation.** A `migrations/`
+ *    directory, a reversible migration that drops a table, a guarded command, a
+ *    manually dispatched workflow, or a command aimed at an ephemeral CI target
+ *    are all reported as observations at most.
+ * 3. **The clean case is a stated SKIP, never PASS.** Whether the danger zones
+ *    are genuinely owned and written down cannot be established by reading
+ *    files; claiming PASS would be the same overstatement B6 exists to catch.
+ * @module cli/doctor-readiness-domain
+ */
+import { describeCommands, hasCheckedInRunbook, looksEphemeral, scanCommands, } from "./doctor-readiness-operations.js";
+import { informationalFindings } from "./doctor-readiness-shared.js";
+import { parseRepositoryWorkflows, } from "./doctor-readiness-workflows.js";
+/** The domain-ownership readiness dimension id (readiness-rubric, RRR-1). */
+export const DOMAIN_OWNERSHIP_DIMENSION_ID = "domain-ownership";
+/** The ship blocker for a realistic path that causes silent data loss. */
+const DOMAIN_BLOCKER_ID = "B1";
+/** Most destructive commands quoted in one finding before summarizing. */
+const MAX_EVIDENCE_COMMANDS = 10;
+/**
+ * Commands that irreversibly destroy stored data. Every entry is a whole
+ * operation, not a keyword: `rm -rf` is deliberately absent because build
+ * outputs and caches dominate its real-world use, and a blocker built on it
+ * would fire on nearly every repository that cleans a `dist/` directory.
+ */
+const IRREVERSIBLE_DATA_OPS = [
+    /\bdrop\s+database\b/,
+    /\bdrop\s+schema\b/,
+    /\btruncate\s+table\b/,
+    /\baws\s+s3\s+rm\b[^\n]*--recursive\b/,
+    /\baws\s+s3\s+rb\b[^\n]*--force\b/,
+    /\baws\s+dynamodb\s+delete-table\b/,
+    /\baws\s+rds\s+delete-db-(instance|cluster)\b[^\n]*--skip-final-snapshot\b/,
+];
+/** Commands that create the way back: a copy taken before the destruction. */
+const RECOVERY_COMMANDS = [
+    /\bpg_dump\b/,
+    /\bmysqldump\b/,
+    /\bbackup\b/,
+    /\bsnapshot\b/,
+    /\baws\s+s3\s+sync\b/,
+];
+/**
+ * Whether a command irreversibly destroys data that is not obviously throwaway.
+ *
+ * The ephemeral screen reads the job's `env:` block alongside the command,
+ * because the evidence is routinely outside the command text: `psql
+ * "$DATABASE_URL" -c "DROP SCHEMA public CASCADE"` says nothing on its own,
+ * while the `DATABASE_URL` it expands to may point at `127.0.0.1` and settle the
+ * question outright.
+ * @param command - The lower-cased `run` command
+ * @param job - The job the command runs in
+ * @returns True when the command is an unambiguous data-destroying operation
+ */
+function destroysData(command, job) {
+    return (IRREVERSIBLE_DATA_OPS.some(pattern => pattern.test(command)) &&
+        !looksEphemeral(`${command}\n${job.env}`));
+}
+/**
+ * State why a job that boots its own `services:` containers cannot be settled.
+ * A job that starts its own database is operating on state it created moments
+ * earlier, so destroying it is not data loss — but proving *which* store the
+ * command targets is beyond an offline read, so this is deferred, not cleared.
+ * @param job - The job to consider
+ * @returns A stated reason, or null when the job starts no services
+ */
+function servicesDeferral(job) {
+    if (job.services.length === 0) {
+        return null;
+    }
+    return (`Job \`${job.id}\` runs a destructive data operation while starting its own ` +
+        `\`services:\` container(s) (${job.services.join(", ")}), which are created ` +
+        "and thrown away inside the run, so whether the command targets durable " +
+        "data is not established either way");
+}
+/**
+ * Whether a job takes its own copy before destroying anything — the way back,
+ * sitting right beside the danger.
+ * @param job - The parsed job
+ * @returns True when any step in the job looks like a backup
+ */
+function jobTakesBackup(job) {
+    return job.steps.some(step => RECOVERY_COMMANDS.some(pattern => pattern.test(step.run.toLowerCase())));
+}
+/**
+ * Build the rubric-shaped B1 finding from the destructive commands it cites.
+ * @param scan - The destructive-operation scan
+ * @returns The B1 finding
+ */
+function domainFinding(scan) {
+    return {
+        blocker: DOMAIN_BLOCKER_ID,
+        invariant_violated: "no realistic path destroys or corrupts data without surfacing an error " +
+            "and leaving a way back",
+        evidence: describeCommands(scan.ungated, MAX_EVIDENCE_COMMANDS),
+        why_proof_missed: "the destructive command is exercised only against real data, so no test " +
+            "run and no review step ever observes what it removes — the pipeline " +
+            "reports green whether the data survived or not",
+        root_correction: "put the operation behind an explicit gate (a job `environment:` or a " +
+            "confirmation input) and give it a way back — a snapshot taken in the " +
+            "same job, or a checked-in runbook naming the restore procedure",
+        machinery_to_remove: [
+            "any unattended destructive step that exists only because no retention " +
+                "or lifecycle policy was configured on the store itself",
+        ],
+    };
+}
+/**
+ * State why the dimension was not settled, naming what WAS looked at so an
+ * operator can tell "nothing to report" from "never looked".
+ * @param inspected - How many workflow files were read
+ * @returns The SKIP reason
+ */
+function skipReason(inspected) {
+    return (`Read ${inspected} workflow file(s) for irreversible data-destroying ` +
+        "operations and found none running unattended and ungated. Whether this " +
+        "repository's business rules, glossary, and danger zones are genuinely " +
+        "owned and written down cannot be established by reading files offline — " +
+        "that needs the agent-ready domain phase — so domain ownership is not " +
+        "established either way.");
+}
+/**
+ * Build the SKIP record, carrying every guarded destructive operation as an
+ * observation. Those observations name no `blocker`: they are the operator's
+ * map of where the danger lives, not a verdict about it.
+ * @param guarded - The destructive commands something already guards
+ * @param scan - The destructive-operation scan
+ * @param inspected - How many workflow files were read
+ * @returns The SKIP dimension record
+ */
+function skipRecord(guarded, scan, inspected) {
+    return {
+        id: DOMAIN_OWNERSHIP_DIMENSION_ID,
+        status: "SKIP",
+        findings: [
+            { reason: skipReason(inspected), skip: true },
+            ...informationalFindings([
+                ...guarded.map(entry => `\`${entry.workflow}\` job \`${entry.jobId}\` runs a destructive ` +
+                    `operation (\`${entry.command}\`) behind a gate, beside its own ` +
+                    "backup, or in a repository that checks in a recovery runbook, so " +
+                    "it was not treated as a silent-data-loss path"),
+                ...scan.unresolved,
+            ]),
+        ],
+    };
+}
+/**
+ * Assess the domain-ownership dimension: B1, "a realistic path causes silent
+ * data loss". Offline by construction — it reads only the repository's declared
+ * workflows — and deliberately conservative: it stands B1 only when a workflow
+ * file alone proves an irreversible data-destroying command runs unattended,
+ * ungated, and with no way back, and renders a stated-reason SKIP in every other
+ * case, including the clean one.
+ * @param root - Project root to assess
+ * @param parsedWorkflows - Pre-parsed workflows (default: parse `root`)
+ * @returns The domain-ownership dimension record
+ */
+export async function assessDomainOwnershipDimension(root, parsedWorkflows) {
+    const workflows = parsedWorkflows ?? (await parseRepositoryWorkflows(root));
+    const scan = scanCommands(workflows, destroysData, {
+        exemptJob: jobTakesBackup,
+        unresolvedJob: servicesDeferral,
+    });
+    // A checked-in runbook is a way back, so it clears the "no recovery" half of
+    // B1 for the whole repository — the blocker asks for BOTH halves at once.
+    const recoverable = await hasCheckedInRunbook(root);
+    if (scan.ungated.length === 0 || recoverable) {
+        return skipRecord(recoverable ? [...scan.gated, ...scan.ungated] : scan.gated, scan, workflows.length);
+    }
+    return {
+        id: DOMAIN_OWNERSHIP_DIMENSION_ID,
+        // `WARN` reports how much confidence an offline read can carry; it does NOT
+        // soften the verdict. The blocker engine never reads this status, so the
+        // finding below flips the repository to `NOT_READY` exactly as `FAIL` would.
+        status: "WARN",
+        findings: [domainFinding(scan), ...informationalFindings(scan.unresolved)],
+    };
+}
+//# sourceMappingURL=doctor-readiness-domain.js.map

package/dist/cli/doctor-readiness-domain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor-readiness-domain.js","sourceRoot":"","sources":["../../src/cli/doctor-readiness-domain.ts"],"names":[],"mappings":"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"}

package/dist/cli/doctor-readiness-guardrails.d.ts

@@ -0,0 +1,15 @@
+import type { ReadinessDimensionRecord } from "./doctor-readiness-types.js";
+import { type ParsedWorkflow } from "./doctor-readiness-workflows.js";
+/** The feedback/guardrails readiness dimension id (readiness-rubric, RRR-1). */
+export declare const FEEDBACK_GUARDRAILS_DIMENSION_ID = "feedback-guardrails";
+/**
+ * Assess the feedback/guardrails dimension: B4, "a consequential operation has
+ * no gate and no recovery". Offline by construction, and honest about it — the
+ * environment-protection-rule half is reasoned-SKIPped in every record, so this
+ * dimension never reports `PASS`. B4 stands only on the file-provable subset.
+ * @param root - Project root to assess
+ * @param parsedWorkflows - Pre-parsed workflows (default: parse `root`)
+ * @returns The feedback/guardrails dimension record
+ */
+export declare function assessFeedbackGuardrailsDimension(root: string, parsedWorkflows?: readonly ParsedWorkflow[]): Promise<ReadinessDimensionRecord>;
+//# sourceMappingURL=doctor-readiness-guardrails.d.ts.map

package/dist/cli/doctor-readiness-guardrails.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor-readiness-guardrails.d.ts","sourceRoot":"","sources":["../../src/cli/doctor-readiness-guardrails.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AAC5E,OAAO,EACL,KAAK,cAAc,EAGpB,MAAM,iCAAiC,CAAC;AAEzC,gFAAgF;AAChF,eAAO,MAAM,gCAAgC,wBAAwB,CAAC;AA0LtE;;;;;;;;GAQG;AACH,wBAAsB,iCAAiC,CACrD,IAAI,EAAE,MAAM,EACZ,eAAe,CAAC,EAAE,SAAS,cAAc,EAAE,GAC1C,OAAO,CAAC,wBAAwB,CAAC,CA6BnC"}

package/dist/cli/doctor-readiness-guardrails.js

@@ -0,0 +1,219 @@
+/**
+ * The feedback/guardrails readiness producer — ship blocker B4 (PRD #1739,
+ * #1896).
+ *
+ * Dimension 5 of the `readiness-rubric` asks whether a failing loop produces a
+ * named outcome and a runbook. B4 asks the operational half: does every
+ * irreversible or expensive operation have a gate AND a way back?
+ *
+ * Only part of that is answerable offline, and saying so plainly is the point.
+ * Whether a declared GitHub `environment:` actually carries protection rules —
+ * required reviewers, wait timers, branch restrictions — lives in the GitHub API,
+ * not in any file this producer can read. That half is therefore a **stated
+ * SKIP in every record emitted here**, never a guess in either direction.
+ *
+ * What remains is a narrow, file-provable subset: a job that runs an
+ * irreversible or expensive operation with **no `environment:` key at all**, no
+ * `if:` gate, reachable from an automated trigger, in a repository that checks
+ * in no runbook. Only that stands B4. Everything else — an ordinary `cdk
+ * deploy`, a CI-database migration, a job that names any environment, a reusable
+ * workflow whose caller is invisible — is an observation at most, because a
+ * standing blocker flips the whole repository to `NOT_READY` and `WARN` does not
+ * soften that.
+ * @module cli/doctor-readiness-guardrails
+ */
+import { describeCommands, hasCheckedInRunbook, looksEphemeral, scanCommands, } from "./doctor-readiness-operations.js";
+import { informationalFindings } from "./doctor-readiness-shared.js";
+import { parseRepositoryWorkflows, } from "./doctor-readiness-workflows.js";
+/** The feedback/guardrails readiness dimension id (readiness-rubric, RRR-1). */
+export const FEEDBACK_GUARDRAILS_DIMENSION_ID = "feedback-guardrails";
+/** The ship blocker for a consequential operation with no gate and no recovery. */
+const GUARDRAILS_BLOCKER_ID = "B4";
+/** Most operations quoted in one finding before summarizing the remainder. */
+const MAX_EVIDENCE_COMMANDS = 10;
+/**
+ * The half of B4 no offline read can settle, stated in every record this
+ * producer emits so an operator is never left to infer that a declared
+ * environment was checked for protection rules. It was not.
+ */
+const PROTECTION_RULES_SKIP_REASON = "Whether a declared `environment:` actually gates anything — required " +
+    "reviewers, wait timers, branch restrictions — is a GitHub environment " +
+    "protection rule, which lives in the GitHub API and is not resolvable " +
+    "offline. That half of this question was deliberately not assessed; only the " +
+    "file-provable half (an irreversible or expensive operation with no " +
+    "`environment:` key at all and no checked-in runbook) was.";
+/**
+ * Operations that are irreversible or expensive enough that running them
+ * unattended is a decision, not a detail. `cdk deploy` and a plain `terraform
+ * apply` are absent on purpose: they are how normal delivery works, and a
+ * blocker that fires on normal delivery is a blocker nobody will believe.
+ */
+const CONSEQUENTIAL_OPS = [
+    /\bterraform\s+(\S+\s+)*apply\b[^\n]*-auto-approve\b/,
+    /\bterraform\s+(\S+\s+)*destroy\b/,
+    /\bcdk\s+destroy\b/,
+    /\bpulumi\s+destroy\b/,
+    /\bpulumi\s+up\b[^\n]*--yes\b/,
+    /\bserverless\s+remove\b/,
+];
+/**
+ * Commands that apply schema migrations, in the ecosystems Lisa templates. The
+ * `(?!:)` lookahead keeps the read-only subcommands out: `db:migrate:status`
+ * and `db:migrate:version` report what has run, they do not run anything.
+ */
+const MIGRATION_COMMANDS = [
+    /\bdb:migrate\b(?!:)/,
+    /\bmigrate\s+deploy\b/,
+    /\bmigration:run\b/,
+    /\balembic\s+upgrade\b/,
+];
+/**
+ * Markers that a command explicitly targets production. A migration is only
+ * consequential when the file itself says it runs against production: the same
+ * command against a CI service container is ordinary test setup, and treating
+ * the two alike is the false positive that would discredit this whole check.
+ */
+const PRODUCTION_MARKERS = [
+    /\b(rails_env|node_env|app_env|django_settings_module|environment)=[^\s]*prod/,
+    /--env(ironment)?[= ]prod/,
+    /\bprod(uction)?\.tfvars\b/,
+];
+/**
+ * Whether a command is an irreversible or expensive operation.
+ *
+ * The ephemeral screen is the same one B1 uses, widened to the per-pull-request
+ * markers this blocker meets constantly: tearing down `pr-1234` or a
+ * `PreviewStack` destroys what the same pipeline built minutes earlier, and
+ * there is nothing durable there for a gate to protect. The job's `env:` block
+ * is read alongside the command, since the stage name usually lives there.
+ * @param command - The lower-cased `run` command
+ * @param job - The job the command runs in
+ * @returns True when the command is consequential on its face
+ */
+function isConsequential(command, job) {
+    if (looksEphemeral(`${command}\n${job.env}`)) {
+        return false;
+    }
+    return (CONSEQUENTIAL_OPS.some(pattern => pattern.test(command)) ||
+        (MIGRATION_COMMANDS.some(pattern => pattern.test(command)) &&
+            PRODUCTION_MARKERS.some(pattern => pattern.test(command))));
+}
+/**
+ * Triggers that fire on the lifecycle of a short-lived resource rather than on
+ * a release. A workflow that runs on a closing pull request or a deleted branch
+ * is tearing down what that branch created.
+ */
+const EPHEMERAL_LIFECYCLE_EVENTS = [
+    "pull_request",
+    "pull_request_target",
+    "delete",
+];
+/**
+ * State why a workflow driven by a branch or pull-request lifecycle cannot be
+ * settled offline. This is deferred rather than cleared: the operation is real,
+ * but whether it touches anything durable is not provable from the file.
+ * @param workflow - The workflow to consider
+ * @returns A stated reason, or null when the trigger is a release-style one
+ */
+function lifecycleDeferral(workflow) {
+    const events = workflow.on.events.filter(event => EPHEMERAL_LIFECYCLE_EVENTS.includes(event));
+    if (events.length === 0) {
+        return null;
+    }
+    return (`\`${workflow.file}\` runs a consequential operation on the \`${events.join(", ")}\` ` +
+        "lifecycle, which tears down what that same branch or pull request created, " +
+        "so whether it ever touches a durable environment is not established " +
+        "either way — no gate was expected and none was required");
+}
+/**
+ * Build the rubric-shaped B4 finding from the operations it cites.
+ * @param scan - The consequential-operation scan
+ * @returns The B4 finding
+ */
+function guardrailsFinding(scan) {
+    return {
+        blocker: GUARDRAILS_BLOCKER_ID,
+        invariant_violated: "every irreversible or expensive operation has a gate before it and a " +
+            "way back after it",
+        evidence: describeCommands(scan.ungated, MAX_EVIDENCE_COMMANDS),
+        why_proof_missed: "the job declares no `environment:` at all, so there is nothing for a " +
+            "protection rule to attach to and nothing for an operator to approve — " +
+            "and with no runbook checked in, the first time anyone works out how to " +
+            "undo the operation is while it is already failing",
+        root_correction: "declare an `environment:` on the job so a protection rule can gate it, " +
+            "and check in a runbook naming the recovery procedure and the run " +
+            "outcome the loop reports, per the `automation-runbook-contract` rule",
+        machinery_to_remove: [
+            "auto-approval flags that exist only because no approval gate was ever " +
+                "configured for the environment the job deploys to",
+        ],
+    };
+}
+/**
+ * Build the SKIP record. Its first finding always states the network-bound half
+ * that was not assessed; the observations below it carry whatever consequential
+ * operations were found to be already gated.
+ * @param scan - The consequential-operation scan
+ * @param inspected - How many workflow files were read
+ * @param runbook - Whether a runbook is checked in
+ * @returns The SKIP dimension record
+ */
+function skipRecord(scan, inspected, runbook) {
+    return {
+        id: FEEDBACK_GUARDRAILS_DIMENSION_ID,
+        status: "SKIP",
+        findings: [
+            {
+                reason: `Read ${inspected} workflow file(s) for irreversible or expensive ` +
+                    "operations and found none that this file alone proves runs " +
+                    `unattended with no gate and no way back (recovery runbook ` +
+                    `${runbook ? "present" : "absent"}). ${PROTECTION_RULES_SKIP_REASON}`,
+                skip: true,
+            },
+            ...informationalFindings([
+                ...scan.gated.map(entry => `\`${entry.workflow}\` job \`${entry.jobId}\` runs a consequential ` +
+                    `operation (\`${entry.command}\`) behind a declared environment, an ` +
+                    "`if:` condition, its own confirmation switch, or in a repository " +
+                    "that checks in a recovery runbook, so it was not treated as " +
+                    "ungated and unrecoverable — whether any such gate carries " +
+                    "protection rules was not checked"),
+                ...scan.unresolved,
+            ]),
+        ],
+    };
+}
+/**
+ * Assess the feedback/guardrails dimension: B4, "a consequential operation has
+ * no gate and no recovery". Offline by construction, and honest about it — the
+ * environment-protection-rule half is reasoned-SKIPped in every record, so this
+ * dimension never reports `PASS`. B4 stands only on the file-provable subset.
+ * @param root - Project root to assess
+ * @param parsedWorkflows - Pre-parsed workflows (default: parse `root`)
+ * @returns The feedback/guardrails dimension record
+ */
+export async function assessFeedbackGuardrailsDimension(root, parsedWorkflows) {
+    const workflows = parsedWorkflows ?? (await parseRepositoryWorkflows(root));
+    const scan = scanCommands(workflows, isConsequential, {
+        unresolvedWorkflow: lifecycleDeferral,
+    });
+    const runbook = await hasCheckedInRunbook(root);
+    if (scan.ungated.length === 0 || runbook) {
+        return skipRecord(runbook ? { ...scan, gated: [...scan.gated, ...scan.ungated] } : scan, workflows.length, runbook);
+    }
+    return {
+        id: FEEDBACK_GUARDRAILS_DIMENSION_ID,
+        // `WARN` reports how much confidence an offline read can carry; it does NOT
+        // soften the verdict. The blocker engine never reads this status.
+        status: "WARN",
+        findings: [
+            guardrailsFinding(scan),
+            // The unassessable half must travel with the standing blocker too:
+            // dropping it here would let a reader believe the gate was checked.
+            ...informationalFindings([
+                PROTECTION_RULES_SKIP_REASON,
+                ...scan.unresolved,
+            ]),
+        ],
+    };
+}
+//# sourceMappingURL=doctor-readiness-guardrails.js.map

package/dist/cli/doctor-readiness-guardrails.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor-readiness-guardrails.js","sourceRoot":"","sources":["../../src/cli/doctor-readiness-guardrails.ts"],"names":[],"mappings":"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"}