@clawcipes/recipes 0.2.2 → 0.2.3

package/docs/COMMANDS.md

@@ -45,6 +45,13 @@ Options:
 - `--apply-config` (write/update `agents.list[]` in OpenClaw config)
 
 ## `scaffold-team <recipeId>`
+
+### Cron installation config
+If a recipe declares `cronJobs`, scaffold will reconcile those jobs using the plugin config key:
+- `plugins.entries.recipes.config.cronInstallation`: `off | prompt | on`
+  - `off`: never install/reconcile
+  - `prompt` (default): prompt each run (default answer is **No**)
+  - `on`: install/reconcile; new jobs follow `enabledByDefault`
 Scaffold a shared **team workspace** + multiple agents from a **team** recipe.
 
 ```bash

package/docs/RECIPE_FORMAT.md

@@ -85,6 +85,26 @@ For team recipes, file templates are namespaced by role:
 
 If a `files[].template` key does not contain a `.`, Clawcipes prefixes it with `<role>.`.
 
+## Cron jobs (optional)
+Recipes can optionally declare cron jobs to be reconciled during `scaffold` / `scaffold-team`.
+
+```yaml
+cronJobs:
+  - id: daily-review
+    schedule: "0 14 * * 1-5"  # 5-field cron
+    message: "Daily review: summarize inbox + calendar for today."
+    enabledByDefault: false
+    timezone: "America/New_York"   # optional
+    channel: "telegram"            # optional (default: last)
+    to: "<chatId or phone>"        # optional
+    description: "Weekday daily review"
+```
+
+Notes:
+- `cronJobs[].id` must be **stable** within the recipe; it’s used for idempotent updates.
+- Safe default behavior is conservative: when `cronInstallation=prompt`, the prompt default is **No**.
+- When the user opts out, jobs are installed **disabled** (so they can be enabled later).
+
 ## Tool policy
 Recipes can include tool policy, which is written into `agents.list[].tools` when `--apply-config` is used:
 

package/docs/shared-context.md

@@ -0,0 +1,47 @@
+# Shared context conventions (team workspaces)
+
+This is a **file-first** coordination convention for scaffolded teams.
+
+## Goals
+- Reduce cross-agent messaging; coordinate via shared files.
+- Prevent shared context from becoming a junk drawer.
+- Make work auditable: read → act → write loops.
+
+## Directory layout
+Team workspaces include:
+
+- `notes/plan.md` — curated plan / priorities (lead-owned)
+- `notes/status.md` — current snapshot (short, updated frequently)
+- `shared-context/` — shared context + append-only inputs
+  - `priorities.md` — curated priorities (lead-owned)
+  - `agent-outputs/` — append-only outputs from non-lead roles
+  - `feedback/` — QA findings / feedback
+  - `kpis/` — metrics
+  - `calendar/` — optional notes
+
+Back-compat:
+- `shared/` may exist as a legacy folder. Prefer `shared-context/`.
+
+## Curator model
+- **Lead** curates:
+  - `notes/plan.md`
+  - `shared-context/priorities.md`
+- **Non-lead roles** should not edit curated files.
+  - Append instead to `shared-context/agent-outputs/` (or `feedback/`).
+
+## Read → Act → Write
+Every role should:
+1) **Read** plan/status + ticket before acting
+2) **Act** (small, safe changes)
+3) **Write back**
+   - update ticket
+   - add 3–5 bullets to `notes/status.md`
+   - append detailed outputs to `shared-context/agent-outputs/`
+
+## Migration guidance (existing teams)
+Safe migration:
+1) Create `shared-context/` and starter subdirs.
+2) Add `shared-context/priorities.md` (create-only; do not overwrite).
+3) Update agent instructions to reference shared-context and curator model.
+
+No existing files need to be deleted or renamed.

package/index.ts

@@ -1,6 +1,7 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import path from "node:path";
 import fs from "node:fs/promises";
+import crypto from "node:crypto";
 import JSON5 from "json5";
 import YAML from "yaml";
 
@@ -11,6 +12,32 @@ type RecipesConfig = {
   workspaceTeamsDir?: string;
   autoInstallMissingSkills?: boolean;
   confirmAutoInstall?: boolean;
+
+  /** Cron installation behavior during scaffold/scaffold-team. */
+  cronInstallation?: "off" | "prompt" | "on";
+};
+
+type CronJobSpec = {
+  /** Stable id within the recipe (used for idempotent reconciliation). */
+  id: string;
+  /** 5-field cron expression */
+  schedule: string;
+  /** Agent message payload */
+  message: string;
+
+  name?: string;
+  description?: string;
+  timezone?: string;
+
+  /** Delivery routing (optional; defaults to OpenClaw "last"). */
+  channel?: string;
+  to?: string;
+
+  /** Which agent should execute this job (optional). */
+  agentId?: string;
+
+  /** If true, install enabled when cronInstallation=on (or prompt-yes). Default false. */
+  enabledByDefault?: boolean;
 };
 
 type RecipeFrontmatter = {
@@ -20,6 +47,9 @@ type RecipeFrontmatter = {
   description?: string;
   kind?: "agent" | "team";
 
+  /** Optional recipe-defined cron jobs to reconcile during scaffold. */
+  cronJobs?: CronJobSpec[];
+
   // skill deps (installed into workspace-local skills dir)
   requiredSkills?: string[];
   optionalSkills?: string[];
@@ -71,6 +101,7 @@ function getCfg(api: OpenClawPluginApi): Required<RecipesConfig> {
     workspaceTeamsDir: cfg.workspaceTeamsDir ?? "teams",
     autoInstallMissingSkills: cfg.autoInstallMissingSkills ?? false,
     confirmAutoInstall: cfg.confirmAutoInstall ?? true,
+    cronInstallation: cfg.cronInstallation ?? "prompt",
   };
 }
 
@@ -157,6 +188,267 @@ async function ensureDir(p: string) {
   await fs.mkdir(p, { recursive: true });
 }
 
+type CronInstallMode = "off" | "prompt" | "on";
+
+type CronMappingStateV1 = {
+  version: 1;
+  entries: Record<
+    string,
+    {
+      installedCronId: string;
+      specHash: string;
+      orphaned?: boolean;
+      updatedAtMs: number;
+    }
+  >;
+};
+
+function cronKey(scope: { kind: "team"; teamId: string; recipeId: string } | { kind: "agent"; agentId: string; recipeId: string }, cronJobId: string) {
+  return scope.kind === "team"
+    ? `team:${scope.teamId}:recipe:${scope.recipeId}:cron:${cronJobId}`
+    : `agent:${scope.agentId}:recipe:${scope.recipeId}:cron:${cronJobId}`;
+}
+
+function hashSpec(spec: unknown) {
+  const json = stableStringify(spec);
+  return crypto.createHash("sha256").update(json, "utf8").digest("hex");
+}
+
+async function readJsonFile<T>(p: string): Promise<T | null> {
+  try {
+    const raw = await fs.readFile(p, "utf8");
+    return JSON.parse(raw) as T;
+  } catch {
+    return null;
+  }
+}
+
+async function writeJsonFile(p: string, data: unknown) {
+  await ensureDir(path.dirname(p));
+  await fs.writeFile(p, JSON.stringify(data, null, 2) + "\n", "utf8");
+}
+
+async function loadCronMappingState(statePath: string): Promise<CronMappingStateV1> {
+  const existing = await readJsonFile<CronMappingStateV1>(statePath);
+  if (existing && existing.version === 1 && existing.entries && typeof existing.entries === "object") return existing;
+  return { version: 1, entries: {} };
+}
+
+type OpenClawCronJob = {
+  id: string;
+  name?: string;
+  enabled?: boolean;
+  schedule?: any;
+  payload?: any;
+  delivery?: any;
+  agentId?: string;
+  description?: string;
+};
+
+function spawnOpenClawJson(args: string[]) {
+  const { spawnSync } = require("node:child_process") as typeof import("node:child_process");
+  const res = spawnSync("openclaw", args, { encoding: "utf8" });
+  if (res.status !== 0) {
+    const err = new Error(`openclaw ${args.join(" ")} failed (exit=${res.status})`);
+    (err as any).stdout = res.stdout;
+    (err as any).stderr = res.stderr;
+    throw err;
+  }
+  const out = String(res.stdout ?? "").trim();
+  return out ? (JSON.parse(out) as any) : null;
+}
+
+function normalizeCronJobs(frontmatter: RecipeFrontmatter): CronJobSpec[] {
+  const raw = frontmatter.cronJobs;
+  if (!raw) return [];
+  if (!Array.isArray(raw)) throw new Error("frontmatter.cronJobs must be an array");
+
+  const out: CronJobSpec[] = [];
+  const seen = new Set<string>();
+  for (const j of raw as any[]) {
+    if (!j || typeof j !== "object") throw new Error("cronJobs entries must be objects");
+    const id = String((j as any).id ?? "").trim();
+    if (!id) throw new Error("cronJobs[].id is required");
+    if (seen.has(id)) throw new Error(`Duplicate cronJobs[].id: ${id}`);
+    seen.add(id);
+
+    const schedule = String((j as any).schedule ?? "").trim();
+    const message = String((j as any).message ?? (j as any).task ?? (j as any).prompt ?? "").trim();
+    if (!schedule) throw new Error(`cronJobs[${id}].schedule is required`);
+    if (!message) throw new Error(`cronJobs[${id}].message is required`);
+
+    out.push({
+      id,
+      schedule,
+      message,
+      name: (j as any).name ? String((j as any).name) : undefined,
+      description: (j as any).description ? String((j as any).description) : undefined,
+      timezone: (j as any).timezone ? String((j as any).timezone) : undefined,
+      channel: (j as any).channel ? String((j as any).channel) : undefined,
+      to: (j as any).to ? String((j as any).to) : undefined,
+      agentId: (j as any).agentId ? String((j as any).agentId) : undefined,
+      enabledByDefault: Boolean((j as any).enabledByDefault ?? false),
+    });
+  }
+  return out;
+}
+
+async function promptYesNo(header: string) {
+  if (!process.stdin.isTTY) return false;
+  const readline = await import("node:readline/promises");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const ans = await rl.question(`${header}\nProceed? (y/N) `);
+    return ans.trim().toLowerCase() === "y" || ans.trim().toLowerCase() === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
+async function reconcileRecipeCronJobs(opts: {
+  recipe: RecipeFrontmatter;
+  scope: { kind: "team"; teamId: string; recipeId: string; stateDir: string } | { kind: "agent"; agentId: string; recipeId: string; stateDir: string };
+  cronInstallation: CronInstallMode;
+}) {
+  const desired = normalizeCronJobs(opts.recipe);
+  if (!desired.length) return { ok: true, changed: false, note: "no-cron-jobs" as const };
+
+  const mode = opts.cronInstallation;
+  if (mode === "off") {
+    return { ok: true, changed: false, note: "cron-installation-off" as const, desiredCount: desired.length };
+  }
+
+  // Decide whether jobs should be enabled on creation. Default is conservative.
+  let userOptIn = mode === "on";
+  if (mode === "prompt") {
+    const header = `Recipe ${opts.scope.recipeId} defines ${desired.length} cron job(s).\nThese run automatically on a schedule. Install them?`;
+    userOptIn = await promptYesNo(header);
+    if (!userOptIn && !process.stdin.isTTY) {
+      console.error("Non-interactive mode: defaulting cron install to disabled.");
+    }
+  }
+
+  const statePath = path.join(opts.scope.stateDir, "notes", "cron-jobs.json");
+  const state = await loadCronMappingState(statePath);
+
+  const list = spawnOpenClawJson(["cron", "list", "--json"]) as { jobs: OpenClawCronJob[] };
+  const byId = new Map((list?.jobs ?? []).map((j) => [j.id, j] as const));
+
+  const now = Date.now();
+  const desiredIds = new Set(desired.map((j) => j.id));
+
+  const results: any[] = [];
+
+  for (const j of desired) {
+    const key = cronKey(opts.scope as any, j.id);
+    const name = j.name ?? `${opts.scope.kind === "team" ? (opts.scope as any).teamId : (opts.scope as any).agentId} • ${opts.scope.recipeId} • ${j.id}`;
+
+    const desiredSpec = {
+      schedule: j.schedule,
+      message: j.message,
+      timezone: j.timezone ?? "",
+      channel: j.channel ?? "last",
+      to: j.to ?? "",
+      agentId: j.agentId ?? "",
+      name,
+      description: j.description ?? "",
+    };
+    const specHash = hashSpec(desiredSpec);
+
+    const prev = state.entries[key];
+    const installedId = prev?.installedCronId;
+    const existing = installedId ? byId.get(installedId) : undefined;
+
+    const wantEnabled = userOptIn ? Boolean(j.enabledByDefault) : false;
+
+    if (!existing) {
+      // Create new job.
+      const args = [
+        "cron",
+        "add",
+        "--json",
+        "--name",
+        name,
+        "--cron",
+        j.schedule,
+        "--message",
+        j.message,
+        "--announce",
+      ];
+      if (!wantEnabled) args.push("--disabled");
+      if (j.description) args.push("--description", j.description);
+      if (j.timezone) args.push("--tz", j.timezone);
+      if (j.channel) args.push("--channel", j.channel);
+      if (j.to) args.push("--to", j.to);
+      if (j.agentId) args.push("--agent", j.agentId);
+
+      const created = spawnOpenClawJson(args) as any;
+      const newId = created?.id ?? created?.job?.id;
+      if (!newId) throw new Error("Failed to parse cron add output (missing id)");
+
+      state.entries[key] = { installedCronId: newId, specHash, updatedAtMs: now, orphaned: false };
+      results.push({ action: "created", key, installedCronId: newId, enabled: wantEnabled });
+      continue;
+    }
+
+    // Update existing job if spec changed.
+    if (prev?.specHash !== specHash) {
+      const editArgs = [
+        "cron",
+        "edit",
+        existing.id,
+        "--name",
+        name,
+        "--cron",
+        j.schedule,
+        "--message",
+        j.message,
+        "--announce",
+      ];
+      if (j.description) editArgs.push("--description", j.description);
+      if (j.timezone) editArgs.push("--tz", j.timezone);
+      if (j.channel) editArgs.push("--channel", j.channel);
+      if (j.to) editArgs.push("--to", j.to);
+      if (j.agentId) editArgs.push("--agent", j.agentId);
+
+      spawnOpenClawJson(editArgs);
+      results.push({ action: "updated", key, installedCronId: existing.id });
+    } else {
+      results.push({ action: "unchanged", key, installedCronId: existing.id });
+    }
+
+    // Enabled precedence: if user did not opt in, force disabled. Otherwise preserve current enabled state.
+    if (!userOptIn) {
+      if (existing.enabled) {
+        spawnOpenClawJson(["cron", "edit", existing.id, "--disable"]);
+        results.push({ action: "disabled", key, installedCronId: existing.id });
+      }
+    }
+
+    state.entries[key] = { installedCronId: existing.id, specHash, updatedAtMs: now, orphaned: false };
+  }
+
+  // Handle removed jobs: disable safely.
+  for (const [key, entry] of Object.entries(state.entries)) {
+    if (!key.includes(`:recipe:${opts.scope.recipeId}:cron:`)) continue;
+    const cronId = key.split(":cron:")[1] ?? "";
+    if (!cronId || desiredIds.has(cronId)) continue;
+
+    const job = byId.get(entry.installedCronId);
+    if (job && job.enabled) {
+      spawnOpenClawJson(["cron", "edit", job.id, "--disable"]);
+      results.push({ action: "disabled-removed", key, installedCronId: job.id });
+    }
+
+    state.entries[key] = { ...entry, orphaned: true, updatedAtMs: now };
+  }
+
+  await writeJsonFile(statePath, state);
+
+  const changed = results.some((r) => r.action === "created" || r.action === "updated" || r.action?.startsWith("disabled"));
+  return { ok: true, changed, results };
+}
+
 function renderTemplate(raw: string, vars: Record<string, string>) {
   // Tiny, safe template renderer: replaces {{key}}.
   // No conditionals, no eval.
@@ -1431,7 +1723,13 @@ const recipesPlugin = {
               await applyAgentSnippetsToOpenClawConfig(api, [result.next.configSnippet]);
             }
 
-            console.log(JSON.stringify(result, null, 2));
+            const cron = await reconcileRecipeCronJobs({
+              recipe,
+              scope: { kind: "agent", agentId: String(options.agentId), recipeId: recipe.id, stateDir: resolvedWorkspaceRoot },
+              cronInstallation: getCfg(api).cronInstallation,
+            });
+
+            console.log(JSON.stringify({ ...result, cron }, null, 2));
           });
 
         cmd
@@ -1477,8 +1775,23 @@ const recipesPlugin = {
             const doneDir = path.join(workDir, "done");
             const assignmentsDir = path.join(workDir, "assignments");
 
+            // Seed standard team files (createOnly unless --overwrite)
+            const overwrite = !!options.overwrite;
+
+            const sharedContextDir = path.join(teamDir, "shared-context");
+            const sharedContextOutputsDir = path.join(sharedContextDir, "agent-outputs");
+            const sharedContextFeedbackDir = path.join(sharedContextDir, "feedback");
+            const sharedContextKpisDir = path.join(sharedContextDir, "kpis");
+            const sharedContextCalendarDir = path.join(sharedContextDir, "calendar");
+
             await Promise.all([
+              // Back-compat: keep existing shared/ folder, but shared-context/ is canonical going forward.
               ensureDir(path.join(teamDir, "shared")),
+              ensureDir(sharedContextDir),
+              ensureDir(sharedContextOutputsDir),
+              ensureDir(sharedContextFeedbackDir),
+              ensureDir(sharedContextKpisDir),
+              ensureDir(sharedContextCalendarDir),
               ensureDir(path.join(teamDir, "inbox")),
               ensureDir(path.join(teamDir, "outbox")),
               ensureDir(notesDir),
@@ -1489,8 +1802,11 @@ const recipesPlugin = {
               ensureDir(assignmentsDir),
             ]);
 
-            // Seed standard team files (createOnly unless --overwrite)
-            const overwrite = !!options.overwrite;
+            // Seed shared-context starter schema (createOnly unless --overwrite)
+            const sharedPrioritiesPath = path.join(sharedContextDir, "priorities.md");
+            const prioritiesMd = `# Priorities — ${teamId}\n\n- (empty)\n\n## Notes\n- Lead curates this file.\n- Non-lead roles should append updates to shared-context/agent-outputs/ instead.\n`;
+            await writeFileSafely(sharedPrioritiesPath, prioritiesMd, overwrite ? "overwrite" : "createOnly");
+
             const planPath = path.join(notesDir, "plan.md");
             const statusPath = path.join(notesDir, "status.md");
             const ticketsPath = path.join(teamDir, "TICKETS.md");
@@ -1550,7 +1866,7 @@ const recipesPlugin = {
 
             // Create a minimal TEAM.md
             const teamMdPath = path.join(teamDir, "TEAM.md");
-            const teamMd = `# ${teamId}\n\nShared workspace for this agent team.\n\n## Folders\n- inbox/ — requests\n- outbox/ — deliverables\n- shared/ — shared artifacts\n- notes/ — notes\n- work/ — working files\n`;
+            const teamMd = `# ${teamId}\n\nShared workspace for this agent team.\n\n## Folders\n- inbox/ — requests\n- outbox/ — deliverables\n- shared-context/ — curated shared context + append-only agent outputs\n- shared/ — legacy shared artifacts (back-compat)\n- notes/ — plan + status\n- work/ — working files\n`;
             await writeFileSafely(teamMdPath, teamMd, options.overwrite ? "overwrite" : "createOnly");
 
             if (options.applyConfig) {
@@ -1558,12 +1874,19 @@ const recipesPlugin = {
               await applyAgentSnippetsToOpenClawConfig(api, snippets);
             }
 
+            const cron = await reconcileRecipeCronJobs({
+              recipe,
+              scope: { kind: "team", teamId, recipeId: recipe.id, stateDir: teamDir },
+              cronInstallation: getCfg(api).cronInstallation,
+            });
+
             console.log(
               JSON.stringify(
                 {
                   teamId,
                   teamDir,
                   agents: results,
+                  cron,
                   next: {
                     note:
                       options.applyConfig

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawcipes/recipes",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Clawcipes recipes plugin for OpenClaw (markdown recipes -> scaffold agents/teams)",
   "main": "index.ts",
   "type": "commonjs",

package/recipes/default/development-team.md

@@ -51,6 +51,32 @@ templates:
     Team: {{teamId}}
     Shared workspace: {{teamDir}}
 
+    ## Guardrails (read → act → write)
+
+    Before you act:
+    1) Read:
+       - `notes/plan.md`
+       - `notes/status.md`
+       - `shared-context/priorities.md`
+       - the relevant ticket(s)
+
+    After you act:
+    1) Write back:
+       - Update tickets with decisions/assignments.
+       - Keep `notes/status.md` current (3–5 bullets per active ticket).
+
+    ## Curator model
+
+    You are the curator of:
+    - `notes/plan.md`
+    - `shared-context/priorities.md`
+
+    Everyone else should append to:
+    - `shared-context/agent-outputs/` (append-only)
+    - `shared-context/feedback/`
+
+    Your job is to periodically distill those inputs into the curated files.
+
     ## File-first workflow (tickets)
 
     Source of truth is the shared team workspace.
@@ -61,8 +87,9 @@ templates:
     - `work/in-progress/` — tickets currently being executed
     - `work/testing/` — tickets awaiting QA verification
     - `work/done/` — completed tickets + completion notes
-    - `notes/plan.md` — current plan / priorities
+    - `notes/plan.md` — current plan / priorities (curated)
     - `notes/status.md` — current status snapshot
+    - `shared-context/` — shared context + append-only outputs
 
     ### Ticket numbering (critical)
     - Backlog tickets MUST be named `0001-...md`, `0002-...md`, etc.
@@ -78,7 +105,8 @@ templates:
 
     ### Your responsibilities
     - For every new request in `inbox/`, create a normalized ticket in `work/backlog/`.
-    - Update `notes/plan.md` and `notes/status.md`.
+    - Curate `notes/plan.md` and `shared-context/priorities.md`.
+    - Keep `notes/status.md` updated.
     - When work is ready for QA, move the ticket to `work/testing/` and assign it to the tester.
     - Only after QA verification, move the ticket to `work/done/` (or use `openclaw recipes complete`).
     - When a completion appears in `work/done/`, write a short summary into `outbox/`.
@@ -94,6 +122,29 @@ templates:
 
     Shared workspace: {{teamDir}}
 
+    ## Guardrails (read → act → write)
+
+    Before you change anything:
+    1) Read:
+       - `notes/plan.md`
+       - `notes/status.md`
+       - `shared-context/priorities.md`
+       - the current ticket you’re working on
+
+    While working:
+    - Keep changes small and safe.
+    - Prefer file-first coordination over chat.
+
+    After you finish a work session (even if not done):
+    1) Write back:
+       - Update the ticket with what you did and what’s next.
+       - Add **3–5 bullets** to `notes/status.md` (what changed / what’s blocked).
+       - Append detailed output to `shared-context/agent-outputs/` (append-only).
+
+    Curator model:
+    - Lead curates `notes/plan.md` and `shared-context/priorities.md`.
+    - You should NOT edit curated files; propose changes via `agent-outputs/`.
+
     ## How you work (pull system)
 
     1) Look in `work/in-progress/` for any ticket already assigned to you.
@@ -122,6 +173,25 @@ templates:
 
     Shared workspace: {{teamDir}}
 
+    ## Guardrails (read → act → write)
+
+    Before you change anything:
+    1) Read:
+       - `notes/plan.md`
+       - `notes/status.md`
+       - `shared-context/priorities.md`
+       - the current ticket you’re working on
+
+    After you finish a work session:
+    1) Write back:
+       - Update the ticket with what you did + verification steps.
+       - Add **3–5 bullets** to `notes/status.md`.
+       - Append detailed output/logs to `shared-context/agent-outputs/` (append-only).
+
+    Curator model:
+    - Lead curates `notes/plan.md` and `shared-context/priorities.md`.
+    - You should NOT edit curated files; propose changes via `agent-outputs/`.
+
     ## How you work (pull system)
 
     1) Look in `work/in-progress/` for any ticket already assigned to you.
@@ -199,6 +269,25 @@ templates:
 
     Shared workspace: {{teamDir}}
 
+    ## Guardrails (read → act → write)
+
+    Before verifying:
+    1) Read:
+       - `notes/plan.md`
+       - `notes/status.md`
+       - `shared-context/priorities.md`
+       - the ticket under test
+
+    After each verification pass:
+    1) Write back:
+       - Add a short verification note to the ticket (pass/fail + evidence).
+       - Add **3–5 bullets** to `notes/status.md` (what’s verified / what’s blocked).
+       - Append detailed findings to `shared-context/feedback/` or `shared-context/agent-outputs/`.
+
+    Curator model:
+    - Lead curates `notes/plan.md` and `shared-context/priorities.md`.
+    - You should NOT edit curated files; propose changes via feedback/outputs.
+
     ## How you work
 
     1) Look in `work/testing/` for tickets assigned to you.