@codyswann/lisa 2.252.0 → 2.253.0

package/plugins/lisa-copilot/skills/lisa-tear-down-automations/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: lisa-tear-down-automations
-description: "Remove every recurring Lisa automation that /setup-automations created for this project (the lisa-auto-<project>-* set: intake-repair, intake-prd, intake-tickets, exploratory-bugs, exploratory-prds, monitor) using the CURRENT runtime's native scheduler — Codex automations or, on Claude, /schedule. This skill is a declarative specification: it identifies WHICH automations to remove; it does not run teardown scripts. Removes only this project's Lisa automations — never other projects' automations or non-Lisa ones. The inverse of /setup-automations."
+description: "Remove every recurring Lisa automation that /setup-automations registered for this project — whatever is actually registered under the lisa-auto-<project>-* prefix, including the opt-in learnings-audit gardener — using the CURRENT runtime's native scheduler — Codex automations or, on Claude, /schedule. This skill is a declarative specification: it identifies WHICH automations to remove; it does not run teardown scripts. Carries no fixed list of loops: the registration set is the roster. Removes only this project's Lisa automations — never other projects' automations or non-Lisa ones. Leaves checked-in runbook files on disk. The inverse of /setup-automations."
 allowed-tools: ["Skill", "Bash", "Read"]
 ---
 
@@ -21,14 +21,34 @@ removes them with its **native** scheduling mechanism.
 
 ## Scope (remove only what setup created)
 
-- Remove the six automations `/setup-automations` creates for the current project, matched by the
-  stable `lisa-auto-<project>-` name prefix: `intake-repair`, `intake-prd`, `intake-tickets`,
-  `exploratory-bugs`, `exploratory-prds`, `monitor`.
+- Remove **every** automation `/setup-automations` registered for the current project — the whole
+  set found under the stable `lisa-auto-<project>-` name prefix, whatever it currently contains.
+  **Membership is registration, not a roster** (`automation-runbook-contract`): sweep the prefix and
+  remove what is there. Do **not** work from a fixed list of loop names — a list drifts the moment a
+  loop is added, which is exactly how the opt-in gardener came to be orphaned.
+- This explicitly includes the opt-in **`learnings-audit`** gardener when it is registered:
+  `/setup-automations learnings-audit=true` registers it under the same prefix, so teardown removes
+  it with the rest. A conditionally-skipped loop (e.g. `exploratory-bugs` on a stack without
+  `exploratory-qa`) simply is not in the sweep.
 - **Never** remove automations for a different project, or any non-Lisa automation (e.g. unrelated
   crawlers/ingestors). Match strictly on the `lisa-auto-<project>-` prefix for THIS project; when in
   doubt about an automation's ownership, leave it and report it rather than deleting it.
-- **Idempotent** — an automation that is already absent is a no-op, not an error.
+- **Idempotent** — an automation that is already absent is a no-op, not an error. Re-running when
+  the prefix sweep finds nothing is a clean, successful no-op.
+- **Leave the runbooks alone.** The checked-in `.lisa/automations/<loop-id>.runbook.md` files that
+  `/setup-automations` scaffolded are project knowledge and the historical record of what these
+  loops did. Teardown removes scheduler registrations only; it never deletes, edits, or moves a
+  runbook file. An operator who wants them gone removes them deliberately, in git.
 
 ## Report
 
-List each automation removed, and any in the expected set that were already absent.
+List each automation removed by name. For "already absent", compare against the one source of truth
+— the fleet `scripts/automation-status-expected-fleet.mjs` (`resolveExpectedAutomationFleet`)
+resolves for this project — and name anything it expects that the sweep did not find; that is a
+no-op, not an error. Do not invent an expected set of your own.
+
+Then state, in the operator's words, that the runbook files under `.lisa/automations/` were left on
+disk **and why**: they are the written record of what those jobs did, kept on purpose, and if you
+do not want them you delete them yourself in git. Finally, confirm that nothing outside this
+project's `lisa-auto-<project>-` prefix was touched. Write it so a non-technical operator can
+confirm what happened without reading code.

package/plugins/lisa-cursor/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa",
-  "version": "2.252.0",
+  "version": "2.253.0",
   "description": "Universal governance — agents, skills, commands, hooks, and rules for all projects",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-cursor/scripts/automation-status-claude-adapter.mjs

@@ -10,6 +10,11 @@
  */
 
 import { compareAutomationFleet } from "./automation-status-contract-drift.mjs";
+import {
+  assignToAutomationGroup,
+  createAutomationGroupBins,
+  renderAutomationGroups,
+} from "./automation-status-expected-fleet.mjs";
 
 const CLAUDE_RUNTIME_LABEL = "Claude /schedule";
 const CLAUDE_ACTIVE_STATUSES = new Set([
@@ -75,10 +80,7 @@ export function inspectClaudeAutomationFleet(input) {
     automationPrefix: expectedFleet.automationPrefix,
   });
 
-  const expectedGroups = new Map([
-    ["core", []],
-    ["exploratory", []],
-  ]);
+  const expectedGroups = createAutomationGroupBins();
 
   const comparisons = compareAutomationFleet({
     expectedAutomations: expectedFleet.expected,
@@ -87,7 +89,9 @@ export function inspectClaudeAutomationFleet(input) {
 
   for (const [index, expected] of expectedFleet.expected.entries()) {
     const comparison = comparisons[index];
-    expectedGroups.get(expected.group)?.push(
+    assignToAutomationGroup(
+      expectedGroups,
+      expected.group,
       createObservedStatusItem({
         expected,
         comparison,
@@ -97,7 +101,7 @@ export function inspectClaudeAutomationFleet(input) {
   }
 
   for (const unsupported of expectedFleet.unsupported) {
-    expectedGroups.get(unsupported.group)?.push({
+    assignToAutomationGroup(expectedGroups, unsupported.group, {
       id: unsupported.automationId,
       status: "UNSUPPORTED",
       summary: unsupported.reason,
@@ -109,18 +113,7 @@ export function inspectClaudeAutomationFleet(input) {
   return {
     runtime: `${CLAUDE_RUNTIME_LABEL} listing`,
     generatedAt: now.toISOString(),
-    groups: [
-      {
-        id: "1",
-        title: "Core automations",
-        items: expectedGroups.get("core") ?? [],
-      },
-      {
-        id: "2",
-        title: "Exploratory automations",
-        items: expectedGroups.get("exploratory") ?? [],
-      },
-    ],
+    groups: renderAutomationGroups(expectedGroups),
     observedAutomations,
   };
 }
@@ -487,6 +480,13 @@ function normalizeClaudeRRule(value) {
   ) {
     return "FREQ=DAILY;INTERVAL=1";
   }
+  if (
+    cadence === "once a week" ||
+    cadence === "every week" ||
+    cadence === "weekly"
+  ) {
+    return "FREQ=WEEKLY;INTERVAL=1";
+  }
 
   const everyMinutes = cadence.match(/every (\d+) minutes?/);
   if (everyMinutes?.[1]) {
@@ -503,6 +503,11 @@ function normalizeClaudeRRule(value) {
     return `FREQ=DAILY;INTERVAL=${everyDays[1]}`;
   }
 
+  const everyWeeks = cadence.match(/every (\d+) weeks?/);
+  if (everyWeeks?.[1]) {
+    return `FREQ=WEEKLY;INTERVAL=${everyWeeks[1]}`;
+  }
+
   return undefined;
 }
 
@@ -527,6 +532,9 @@ function humanizeClaudeCadence(value) {
   if (normalized === "every day") {
     return "once a day";
   }
+  if (normalized === "weekly" || normalized === "every week") {
+    return "once a week";
+  }
   return normalized;
 }
 
@@ -556,6 +564,11 @@ function humanizeRRule(rrule) {
     return Number(daily[1]) === 1 ? "once a day" : `every ${daily[1]} days`;
   }
 
+  const weekly = rrule.match(/^FREQ=WEEKLY;INTERVAL=(\d+)$/);
+  if (weekly?.[1]) {
+    return Number(weekly[1]) === 1 ? "once a week" : `every ${weekly[1]} weeks`;
+  }
+
   return rrule;
 }
 
@@ -574,6 +587,11 @@ function cadenceLabelToIntervalMs(label) {
     return 24 * 60 * 60_000;
   }
 
+  const oncePerWeek = new Set(["once a week", "weekly"]);
+  if (oncePerWeek.has(label)) {
+    return 7 * 24 * 60 * 60_000;
+  }
+
   return null;
 }
 

package/plugins/lisa-cursor/scripts/automation-status-codex-adapter.mjs

@@ -17,6 +17,11 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 
 import { compareAutomationFleet } from "./automation-status-contract-drift.mjs";
+import {
+  assignToAutomationGroup,
+  createAutomationGroupBins,
+  renderAutomationGroups,
+} from "./automation-status-expected-fleet.mjs";
 
 const CODEx_RUNTIME_LABEL = "Codex automations";
 const RUN_TIMESTAMP_PATTERN = /20\d{2}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.\d+)?Z/;
@@ -156,10 +161,7 @@ export async function inspectCodexAutomationFleet(input) {
     automationPrefix: expectedFleet.automationPrefix,
   });
 
-  const expectedGroups = new Map([
-    ["core", []],
-    ["exploratory", []],
-  ]);
+  const expectedGroups = createAutomationGroupBins();
 
   const comparisons = compareAutomationFleet({
     expectedAutomations: expectedFleet.expected,
@@ -168,7 +170,9 @@ export async function inspectCodexAutomationFleet(input) {
 
   for (const [index, expected] of expectedFleet.expected.entries()) {
     const comparison = comparisons[index];
-    expectedGroups.get(expected.group)?.push(
+    assignToAutomationGroup(
+      expectedGroups,
+      expected.group,
       createObservedStatusItem({
         expected,
         comparison,
@@ -178,7 +182,7 @@ export async function inspectCodexAutomationFleet(input) {
   }
 
   for (const unsupported of expectedFleet.unsupported) {
-    expectedGroups.get(unsupported.group)?.push({
+    assignToAutomationGroup(expectedGroups, unsupported.group, {
       id: unsupported.automationId,
       status: "UNSUPPORTED",
       summary: unsupported.reason,
@@ -190,18 +194,7 @@ export async function inspectCodexAutomationFleet(input) {
   return {
     runtime: `${CODEx_RUNTIME_LABEL} (backing-store metadata)`,
     generatedAt: now.toISOString(),
-    groups: [
-      {
-        id: "1",
-        title: "Core automations",
-        items: expectedGroups.get("core") ?? [],
-      },
-      {
-        id: "2",
-        title: "Exploratory automations",
-        items: expectedGroups.get("exploratory") ?? [],
-      },
-    ],
+    groups: renderAutomationGroups(expectedGroups),
     observedAutomations,
   };
 }
@@ -249,21 +242,35 @@ export function deriveCodexObservedCommand(prompt) {
     return undefined;
   }
 
+  // The "with arguments" clause is optional: no-argument loops (monitor, the
+  // gardener) register without one. Requiring it made every such loop derive an
+  // undefined command and report DRIFTED forever, un-fixable by re-running setup.
   const lisaSkillMatch = prompt.match(
-    /Use the Lisa ([a-z0-9:-]+) skill with arguments `([^`]+)`/i
+    /Use the Lisa ([a-z0-9:-]+) skill(?: with arguments `([^`]*)`)?/i
   );
-  if (lisaSkillMatch?.[1] && lisaSkillMatch[2]) {
-    return `/lisa:${lisaSkillMatch[1]} ${lisaSkillMatch[2]}`.trim();
+  if (lisaSkillMatch?.[1]) {
+    return `/lisa:${lisaSkillMatch[1]} ${lisaSkillMatch[2] ?? ""}`.trim();
   }
 
   const aliasSkillMatch = prompt.match(
-    /Use the `\$([a-z0-9:-]+)` skill with arguments `([^`]+)`/i
+    /Use the `\$([a-z0-9:-]+)` skill(?: with arguments `([^`]*)`)?/i
   );
-  if (aliasSkillMatch?.[1] && aliasSkillMatch[2]) {
-    return `${canonicalizeCodexSkillAlias(aliasSkillMatch[1])} ${aliasSkillMatch[2]}`.trim();
-  }
-
-  return undefined;
+  if (aliasSkillMatch?.[1]) {
+    return `${canonicalizeCodexSkillAlias(aliasSkillMatch[1])} ${aliasSkillMatch[2] ?? ""}`.trim();
+  }
+
+  // A registration whose prompt carries the literal Lisa command on its own
+  // line — the shape `/lisa:setup-automations` bakes so a command that is not a
+  // plain skill name (`/lisa:learnings:audit`) round-trips exactly. Mirrors the
+  // Claude adapter, which has always accepted a bare `/lisa:` command. Codex
+  // stores prompts as single-line TOML, so a line break arrives either real or
+  // as the two-character escape `\n`; both delimit a line here.
+  const literalCommand = prompt
+    .split(/\r?\n|\\n/)
+    .map(segment => segment.trim())
+    .find(segment => /^\/lisa[:-]\S/.test(segment));
+
+  return literalCommand;
 }
 
 function canonicalizeCodexSkillAlias(alias) {
@@ -583,6 +590,13 @@ function humanizeAutomationCadence(rrule) {
       : `every ${everyDays[1]} days`;
   }
 
+  const everyWeeks = rrule.match(/^FREQ=WEEKLY;INTERVAL=(\d+)$/);
+  if (everyWeeks?.[1]) {
+    return Number(everyWeeks[1]) === 1
+      ? "once a week"
+      : `every ${everyWeeks[1]} weeks`;
+  }
+
   return rrule;
 }
 
@@ -606,6 +620,11 @@ function rruleToIntervalMs(rrule) {
     return Number(daily[1]) * 24 * 60 * 60_000;
   }
 
+  const weekly = rrule.match(/^FREQ=WEEKLY;INTERVAL=(\d+)$/);
+  if (weekly?.[1]) {
+    return Number(weekly[1]) * 7 * 24 * 60 * 60_000;
+  }
+
   return null;
 }
 
@@ -623,6 +642,10 @@ function cadenceLabelToIntervalMs(label) {
     return 24 * 60 * 60_000;
   }
 
+  if (label === "once a week") {
+    return 7 * 24 * 60 * 60_000;
+  }
+
   return null;
 }
 

package/plugins/lisa-cursor/scripts/automation-status-expected-fleet.mjs

@@ -37,10 +37,86 @@ export const AUTOMATION_EXPECTED_CADENCES = {
     human: "once a day",
     rrule: "FREQ=DAILY;INTERVAL=1",
   },
+  monitor: {
+    human: "once a day",
+    rrule: "FREQ=DAILY;INTERVAL=1",
+  },
+  "learnings-audit": {
+    human: "once a week",
+    rrule: "FREQ=WEEKLY;INTERVAL=1",
+  },
 };
 
 export const EXPLORATORY_QA_STACK_PRIORITY = ["expo", "rails", "harper-fabric"];
 
+/**
+ * Directory (repo-relative) holding the checked-in per-loop runbooks scaffolded
+ * by `/lisa:setup-automations` per the `automation-runbook-contract` rule.
+ */
+export const AUTOMATION_RUNBOOK_DIRECTORY = ".lisa/automations";
+
+/**
+ * Every fleet group, in render order, with the operator-facing title each one
+ * carries in the status report. This is the single source of truth for group
+ * membership: adapters bin entries with {@link createAutomationGroupBins} and
+ * render with {@link renderAutomationGroups}, so adding a group here surfaces it
+ * everywhere instead of silently dropping its entries.
+ */
+export const AUTOMATION_FLEET_GROUP_TITLES = {
+  core: "Core automations",
+  exploratory: "Exploratory automations",
+  "opt-in": "Opt-in automations",
+};
+
+/**
+ * Create one empty bin per known fleet group.
+ *
+ * @returns {Map<string, object[]>}
+ */
+export function createAutomationGroupBins() {
+  return new Map(
+    Object.keys(AUTOMATION_FLEET_GROUP_TITLES).map(group => [group, []])
+  );
+}
+
+/**
+ * Add a rendered status item to its group bin.
+ *
+ * Throws on an unknown group rather than dropping the item: a silently skipped
+ * entry is indistinguishable from a healthy fleet, which is exactly how the
+ * opt-in gardener went missing from both runtime adapters.
+ *
+ * @param {Map<string, object[]>} bins
+ * @param {string} group
+ * @param {object} item
+ * @returns {void}
+ */
+export function assignToAutomationGroup(bins, group, item) {
+  const bin = bins.get(group);
+  if (!bin) {
+    throw new Error(
+      `Unknown automation fleet group "${group}" for ${item?.id ?? "an automation"}. Add it to AUTOMATION_FLEET_GROUP_TITLES so the status report can render it.`
+    );
+  }
+  bin.push(item);
+}
+
+/**
+ * Render the group bins as the numbered report groups, in declaration order.
+ *
+ * @param {Map<string, object[]>} bins
+ * @returns {readonly { readonly id: string, readonly title: string, readonly items: readonly object[] }[]}
+ */
+export function renderAutomationGroups(bins) {
+  return Object.entries(AUTOMATION_FLEET_GROUP_TITLES).map(
+    ([group, title], index) => ({
+      id: String(index + 1),
+      title,
+      items: bins.get(group) ?? [],
+    })
+  );
+}
+
 /**
  * @typedef {{
  *   readonly id: string
@@ -48,19 +124,52 @@ export const EXPLORATORY_QA_STACK_PRIORITY = ["expo", "rails", "harper-fabric"];
  *   readonly expectedCadence: string
  *   readonly expectedRRule: string
  *   readonly expectedCommand: string
- *   readonly group: "core" | "exploratory"
+ *   readonly group: "core" | "exploratory" | "opt-in"
+ *   readonly runbookPath: string
  * }} ExpectedAutomationEntry
  *
  * @typedef {{
  *   readonly id: string
  *   readonly automationId: string
- *   readonly group: "core" | "exploratory"
+ *   readonly group: "core" | "exploratory" | "opt-in"
  *   readonly reason: string
  *   readonly expectedCadence: string
  *   readonly expectedRRule: string
+ *   readonly runbookPath: string
  * }} UnsupportedAutomationEntry
  */
 
+/**
+ * Infer whether this project opted into the weekly gardener, from what is
+ * actually registered on the scheduler.
+ *
+ * Membership is registration, not configuration: there is no config key to
+ * read, so a read-only caller decides by looking for the registration itself.
+ * Pass the result as `learningsAudit` to {@link resolveExpectedAutomationFleet}
+ * so an opted-in project compares its gardener like any other loop instead of
+ * reporting it `UNSUPPORTED` forever.
+ *
+ * @param {{
+ *   readonly automationPrefix: string
+ *   readonly observedAutomationIds?: readonly string[]
+ * }} input
+ * @returns {boolean}
+ */
+export function inferLearningsAuditRegistration(input) {
+  const target = `${input.automationPrefix}learnings-audit`;
+  return (input.observedAutomationIds ?? []).includes(target);
+}
+
+/**
+ * Resolve the repo-relative runbook path for a loop id.
+ *
+ * @param {string} id
+ * @returns {string}
+ */
+export function resolveAutomationRunbookPath(id) {
+  return `${AUTOMATION_RUNBOOK_DIRECTORY}/${id}.runbook.md`;
+}
+
 /**
  * Resolve the stable project identifier and automation prefix used by
  * `/lisa:setup-automations`.
@@ -101,7 +210,15 @@ export function resolveAutomationProjectIdentity(input = {}) {
  *   readonly detectedTypes?: readonly string[]
  *   readonly autoStartPrds?: boolean | string
  *   readonly autoStartTickets?: boolean | string
+ *   readonly learningsAudit?: boolean | string
  * }} input
+ *
+ * `learningsAudit` has no config home by design — the gardener is opted into at
+ * registration time, and membership is registration, not configuration. A
+ * read-only caller (the status surface) therefore INFERS it: pass `true` when a
+ * `<automationPrefix>learnings-audit` entry is observed on the runtime
+ * scheduler. Without that inference an opted-in project would report the
+ * gardener `UNSUPPORTED` forever instead of comparing it like any other loop.
  * @returns {{
  *   readonly owner: string
  *   readonly repo: string
@@ -116,6 +233,7 @@ export function resolveExpectedAutomationFleet(input = {}) {
   const identity = resolveAutomationProjectIdentity(input);
   const autoStartPrds = normalizeBooleanFlag(input.autoStartPrds);
   const autoStartTickets = normalizeBooleanFlag(input.autoStartTickets);
+  const learningsAudit = normalizeBooleanFlag(input.learningsAudit);
   const detectedTypes = input.detectedTypes ?? [];
 
   const tracker = config.tracker;
@@ -166,6 +284,7 @@ export function resolveExpectedAutomationFleet(input = {}) {
       `/lisa:intake ${buildQueue}`,
       "core"
     ),
+    createExpectedEntry(identity, "monitor", "/lisa:monitor", "core"),
     createExpectedEntry(
       identity,
       "exploratory-prds",
@@ -191,7 +310,28 @@ export function resolveExpectedAutomationFleet(input = {}) {
       createUnsupportedEntry(
         identity,
         "exploratory-bugs",
-        "This repository does not ship an exploratory-qa command surface."
+        "This project ships no exploratory-qa command, so there is nothing for this loop to run. No action needed unless the project adds one.",
+        "exploratory"
+      )
+    );
+  }
+
+  if (learningsAudit) {
+    expected.push(
+      createExpectedEntry(
+        identity,
+        "learnings-audit",
+        "/lisa:learnings:audit",
+        "opt-in"
+      )
+    );
+  } else {
+    unsupported.push(
+      createUnsupportedEntry(
+        identity,
+        "learnings-audit",
+        "The weekly gardener loop is opt-in and this project has not opted in, so nobody is auditing its knowledge surfaces. Run /lisa:setup-automations learnings-audit=true to enable it.",
+        "opt-in"
       )
     );
   }
@@ -222,7 +362,7 @@ export function resolveExploratoryQaStack(detectedTypes = []) {
  * @param {{ readonly automationPrefix: string }} identity
  * @param {string} id
  * @param {string} expectedCommand
- * @param {"core" | "exploratory"} group
+ * @param {"core" | "exploratory" | "opt-in"} group
  * @returns {ExpectedAutomationEntry}
  */
 function createExpectedEntry(identity, id, expectedCommand, group) {
@@ -234,6 +374,7 @@ function createExpectedEntry(identity, id, expectedCommand, group) {
     expectedRRule: cadence.rrule,
     expectedCommand,
     group,
+    runbookPath: resolveAutomationRunbookPath(id),
   };
 }
 
@@ -241,17 +382,19 @@ function createExpectedEntry(identity, id, expectedCommand, group) {
  * @param {{ readonly automationPrefix: string }} identity
  * @param {string} id
  * @param {string} reason
+ * @param {"core" | "exploratory" | "opt-in"} group
  * @returns {UnsupportedAutomationEntry}
  */
-function createUnsupportedEntry(identity, id, reason) {
+function createUnsupportedEntry(identity, id, reason, group) {
   const cadence = AUTOMATION_EXPECTED_CADENCES[id];
   return {
     id,
     automationId: `${identity.automationPrefix}${id}`,
     expectedCadence: cadence.human,
     expectedRRule: cadence.rrule,
-    group: "exploratory",
+    group,
     reason,
+    runbookPath: resolveAutomationRunbookPath(id),
   };
 }
 

package/plugins/lisa-cursor/skills/lisa-automation-status/SKILL.md

@@ -16,14 +16,20 @@ Do **not** ask for confirmation once invoked. This skill inspects scheduler stat
 
 ## Scope
 
-Inspect only the Lisa automation fleet for the current project:
-
-- `intake-repair`
-- `intake-prd`
-- `intake-tickets`
-- `exploratory-bugs` when the current stack supports `exploratory-qa`
-- `exploratory-prds`
-- `monitor`
+Inspect only the Lisa automation fleet for the current project. Derive that fleet from
+`scripts/automation-status-expected-fleet.mjs` (`resolveExpectedAutomationFleet`), which resolves
+exactly what `setup-automations` registers for this repo — including the stack-guarded
+`exploratory-bugs` and the opt-in `learnings-audit` gardener. **Membership is registration, not a
+roster** (`automation-runbook-contract`): carry no fixed list of loop names here, so a loop added to
+or removed from the registration set flows through without editing this skill.
+
+The gardener is opted into at registration time and has no config key, so **infer it from the
+scheduler**: list the project's automations first, then call
+`inferLearningsAuditRegistration({ automationPrefix, observedAutomationIds })` and pass the result
+as `learningsAudit` when resolving the fleet. A `lisa-auto-<project>-learnings-audit` entry on the
+scheduler means the project opted in, so the gardener is compared like any other loop; no such entry
+means it is reported `UNSUPPORTED` (opted out), never `MISSING`. This skill stays read-only — it
+infers, it never writes the flag anywhere.
 
 Resolve the expected project identifier, fleet naming prefix, queue arguments, cadence, and stack-support rules from the same contract used by `setup-automations` and `tear-down-automations`. Do **not** invent a second source of truth for fleet naming or queue resolution.