--- name: "rar-cowork-cookbook-audit-and-surface-against-a-standard" description: "Audits every file in a specified folder against a named standard and returns a sortable Excel report of violations by severity (Critical/Major/Minor) with impact and recommended fixes; makes no changes to files." metadata: {"projection": "rar-scout/1.0", "rar_agent": "@cowork-cookbook/audit_and_surface_against_a_standard", "rar_sha256": "c57c41ca65305e8cb2417f858aa4b1e445a56e9af710f4892ba5dc1a1a462f9c", "source_kind": "rar-agent", "source_commit": "597f0992f4120ddef24dd8686c5720a9ba5b59ab", "version": "3.0.2", "author": "Sean Galliher and Cowork Cookbook contributors", "tags": ["industry_solution", "business_process", "prompt", "audit", "work_management", "advanced", "read_only", "analysis"]} --- ## Microsoft Scout runtime This is the reversible Scout projection of `@cowork-cookbook/audit_and_surface_against_a_standard`. The original RAPP agent is preserved byte-for-byte in `audit_and_surface_against_a_standard_agent.py` and in the RCI capsule. When Scout can execute local files, resolve this skill directory and run: ```bash python3 scripts/run_agent.py --preflight echo '{}' | python3 scripts/run_agent.py ``` Pass the real JSON arguments instead of `{}`. The runner verifies the linked agent SHA-256 before importing it. If preflight reports a host dependency that Scout cannot satisfy, use the `brainstem_chat` MCP tool to run the canonical agent in the user's Brainstem. Never paraphrase the factory or agent into a new implementation. The generic direct-file commands in the generated Toaster section are recovery guidance; Scout should prefer the verified runner. Audit and surface against a standard — Audits every file in a specified folder against a named standard and returns a sortable Excel report of violations by severity (Critical/Major/Minor) with impact and recommended fixes; makes no changes to files. AGGREGATED ENTRY. The content authority for this capability is the upstream library; this file is the structured RAR container for it. It carries a manifest, a version locked to upstream, a content hash, a provenance record and a public feedback thread — none of which the upstream entry has on its own. This entry carries the upstream recipe itself, under its licence and with attribution: the prompt verbatim, the prerequisites, the step-by-step and the expected output. Toasting made it deterministic — the same call returns the same recipe every time — and callable from any Brainstem. The upstream library remains the authority for the recipe and links home for the source. Source library : Cowork Cookbook (Sean Galliher and Cowork Cookbook contributors) Upstream entry : https://coworkcookbook.com/recipes/audit-and-surface-against-a-standard Upstream author: Sean Galliher and Cowork Cookbook contributors Upstream version: 1.0.0 Licence : CC-BY-4.0 Regenerated automatically by scripts/generate_aggregated_agents.py whenever the upstream record changes, so this file and its source cannot silently diverge. ## Parameters The typed contract this capability answers to (JSON Schema — the deterministic layer): ```json { "properties": { "context": { "description": "Optional. Details the recipe should use \u2014 the record, scope, dates or filters it asks for.", "type": "string" }, "folder": { "description": "The folder or location containing the items to audit.", "type": "string" }, "item_type": { "description": "The kind of item to review, e.g. file, image, asset, or document.", "type": "string" }, "operation": { "description": "What to do: run, prompt, plan, checklist, describe.", "enum": [ "run", "prompt", "plan", "checklist", "describe" ], "type": "string" }, "standard": { "description": "The standard to audit against: brand guidelines, compliance policy, naming convention, or internal quality standard.", "type": "string" } }, "required": [ "operation" ], "type": "object" } ``` ## Run this — do not improvise This capability's deterministic implementation is a RAPP single-file agent, linked beside this file as `audit_and_surface_against_a_standard_agent.py` and embedded as the fenced Python below (sha256 c57c41ca65305e8c…; a byte-exact copy is also vaulted in the capsule comment at the end of this file). On a host with sandbox execution, run the linked file directly — if it is missing, write the fence contents verbatim to `audit_and_surface_against_a_standard_agent.py` first: ```bash python3 audit_and_surface_against_a_standard_agent.py '{"key": "value"}' # arguments as one JSON object echo '{"key": "value"}' | python3 audit_and_surface_against_a_standard_agent.py # or on stdin python3 audit_and_surface_against_a_standard_agent.py --tool # emit the JSON tool contract ``` Treat stdout as a tool result. If it reports missing or unresolved inputs, stop and collect them. If it returns `steps`, execute those steps in order exactly as returned; if it returns `instructions`, follow them with the supplied inputs. Otherwise use the result verbatim. Do not invent behavior beyond that output. On a host without code execution, treat the Parameters schema and the code below as the exact specification and never paraphrase a step. Never edit inside the generated markers; a converter-equipped host can instead restore the original file checksum-verified with the installed `rapp-agent-converter/scripts/toast.py convert SKILL.md --to agent`. ```python # rapp:deterministic """ Audit and surface against a standard — Audits every file in a specified folder against a named standard and returns a sortable Excel report of violations by severity (Critical/Major/Minor) with impact and recommended fixes; makes no changes to files. AGGREGATED ENTRY. The content authority for this capability is the upstream library; this file is the structured RAR container for it. It carries a manifest, a version locked to upstream, a content hash, a provenance record and a public feedback thread — none of which the upstream entry has on its own. This entry carries the upstream recipe itself, under its licence and with attribution: the prompt verbatim, the prerequisites, the step-by-step and the expected output. Toasting made it deterministic — the same call returns the same recipe every time — and callable from any Brainstem. The upstream library remains the authority for the recipe and links home for the source. Source library : Cowork Cookbook (Sean Galliher and Cowork Cookbook contributors) Upstream entry : https://coworkcookbook.com/recipes/audit-and-surface-against-a-standard Upstream author: Sean Galliher and Cowork Cookbook contributors Upstream version: 1.0.0 Licence : CC-BY-4.0 Regenerated automatically by scripts/generate_aggregated_agents.py whenever the upstream record changes, so this file and its source cannot silently diverge. """ __manifest__ = { "schema": "rapp-agent/1.0", "name": '@cowork-cookbook/audit_and_surface_against_a_standard', "version": '3.0.2', "display_name": 'Audit and surface against a standard', "description": 'Audits every file in a specified folder against a named standard and returns a sortable Excel report of violations by severity (Critical/Major/Minor) with impact and recommended fixes; makes no changes to files.', "author": 'Sean Galliher and Cowork Cookbook contributors', "tags": ['industry_solution', 'business_process', 'prompt', 'audit', 'work_management', 'advanced', 'read_only', 'analysis'], "category": 'analysis', "quality_tier": 'community', "requires_env": [], "dependencies": ["@rapp/basic_agent"], # Provenance. `content_digest` fingerprints the upstream record; when it # moves, this file is regenerated. `--check` fails the build on drift. "source": { "aggregated": True, "source_id": 'cowork-cookbook', "source_name": 'Cowork Cookbook', "source_url": 'https://coworkcookbook.com/', "upstream_slug": 'audit-and-surface-against-a-standard', "upstream_url": 'https://coworkcookbook.com/recipes/audit-and-surface-against-a-standard', "upstream_version": '1.0.0', "license": 'CC-BY-4.0', "license_verified": True, "details": {'license_note': "Recipe content is CC BY 4.0 (share and adapt with attribution) and code is MIT. RAR carries each recipe's prompt, prerequisites, steps and expected output verbatim with attribution, so the toasted agent runs the real recipe; bundles and screenshots stay upstream.", 'license_url': 'https://github.com/seangalliher/Coworkcookbook/blob/main/LICENSE', 'repository_url': 'https://github.com/seangalliher/Coworkcookbook', 'taxonomy_url': 'https://coworkcookbook.com/data/taxonomy.json'}, "content_digest": '755d198aabc53809', }, "industry_context": {'deprecated': False, 'difficulty': 'advanced', 'last_verified_on': None, 'mutates_data': False, 'plugin': 'none', 'process_roots': ['work-management'], 'process_tags': ['work-management/review-against-standards/audit-content-against-a-standard'], 'recipe_category': 'audit', 'recipe_type': 'prompt', 'upstream_path': 'work-management/audit-and-surface-against-a-standard', 'uses_skills': {'custom': [], 'ootb': ['Excel'], 'plugin': []}, 'verification_status': 'draft'}, # The platforms the upstream entry targets. First-class and queryable, not # buried in prose: this is what lets the registry answer "what can I launch # into Copilot Studio / Cowork / Scout", which is the whole reason an # agent.py container beats a bare skill entry for cross-platform reach. "platforms": ['Microsoft 365 Copilot Cowork'], } try: from agents.basic_agent import BasicAgent except ModuleNotFoundError: class BasicAgent: def __init__(self, name, metadata): self.name = name self.metadata = metadata # The toasted capability, generated by @kody-w/skill_toaster_agent. A licensed # recipe entry carries the upstream recipe verbatim (with attribution) in # _SPEC["recipe"]; a metadata-only entry carries RAR's own method for that shape # of work. See the module docstring for which this is. _SPEC = {'archetype': 'recipe', 'checks': ['Prerequisite: Microsoft 365 Copilot licence with access to Cowork', 'Output matches: A sortable audit report showing every violation, its severity, and a recommended fix - so you can prioritize manual cleanup confidently.'], 'confidence': 1.0, 'deliverable': 'A sortable audit report showing every violation, its severity, and a recommended fix - so you can prioritize manual cleanup confidently.', 'operations': ['run', 'prompt', 'plan', 'checklist', 'describe'], 'params': {'context': 'Optional. Details the recipe should use — the record, scope, dates or filters it asks for.', 'folder': 'The folder or location containing the items to audit.', 'item_type': 'The kind of item to review, e.g. file, image, asset, or document.', 'standard': 'The standard to audit against: brand guidelines, compliance policy, naming convention, or internal quality standard.'}, 'recipe': {'authors': ['Sean Galliher'], 'business_value': 'Apply a brand guide, naming convention, compliance policy, or quality standard across dozens of files - without manually reviewing each one and without risking accidental changes. A sortable audit report showing every violation, its severity, and a recommended fix - so you can prioritize manual cleanup confidently.', 'expected_output': 'A sortable audit report showing every violation, its severity, and a recommended fix - so you can prioritize manual cleanup confidently.', 'platform': 'Microsoft 365 Copilot Cowork', 'prerequisites': ['Microsoft 365 Copilot licence with access to Cowork'], 'prompt': "Audit every [file / image / asset / document] in [folder] against [our standard / brand guidelines / compliance policy / naming convention]. Read each one in full.\n\nCategorize violations by severity:\n\nCritical\n\nMajor\n\nMinor\n\nFor each violation, describe the issue, the impact, and a specific recommended fix.\n\nProduce a sortable Excel report showing total items reviewed, violations by category, the most common issues, and the recommended order to address them.\n\nDon't change any files - give me the action list.", 'steps': ['Open Cowork and start a new task.', 'Paste the prompt from `prompt.md`, replacing anything in square brackets with your own values.', 'Review the plan Cowork proposes before letting it run.', 'Check any drafted email or calendar change before approving it — the prompt holds them for review rather than sending.'], 'tenant_caveat': '', 'verified_against': '', 'what_it_does': 'A sortable audit report showing every violation, its severity, and a recommended fix - so you can prioritize manual cleanup confidently.'}, 'refined_by': 'claude-opus-5', 'refinement': {'description': 'Audits every file in a specified folder against a named standard and returns a sortable Excel report of violations by severity (Critical/Major/Minor) with impact and recommended fixes; makes no changes to files.', 'example_request': 'Audit every document in our Q4 Marketing folder against our brand guidelines and give me an Excel action list.', 'inputs': [{'description': 'The kind of item to review, e.g. file, image, asset, or document.', 'name': 'item_type'}, {'description': 'The folder or location containing the items to audit.', 'name': 'folder'}, {'description': 'The standard to audit against: brand guidelines, compliance policy, naming convention, or internal quality standard.', 'name': 'standard'}], 'model': 'claude-opus-5', 'when_to_use': 'Call when a user wants dozens of files checked against a brand guide, naming convention, compliance policy, or quality standard without editing them.'}, 'signals': ['recipe:prompt', 'refined'], 'steps': ['Open Cowork and start a new task.', 'Paste the prompt from `prompt.md`, replacing anything in square brackets with your own values.', 'Review the plan Cowork proposes before letting it run.', 'Check any drafted email or calendar change before approving it — the prompt holds them for review rather than sending.'], 'subject_label': 'context for the recipe', 'verb': 'Run'} class AuditAndSurfaceAgainstAStandard(BasicAgent): """Run agent, toasted from an aggregated upstream entry.""" def __init__(self): self.name = 'AuditAndSurfaceAgainstAStandard' self.metadata = { "name": self.name, "display_name": __manifest__["display_name"], "description": __manifest__["description"], "parameters": { "type": "object", "properties": {'context': {'description': 'Optional. Details the recipe should use — the record, scope, dates or filters it asks for.', 'type': 'string'}, 'folder': {'description': 'The folder or location containing the items to audit.', 'type': 'string'}, 'item_type': {'description': 'The kind of item to review, e.g. file, image, asset, or document.', 'type': 'string'}, 'operation': {'description': 'What to do: run, prompt, plan, checklist, describe.', 'enum': ['run', 'prompt', 'plan', 'checklist', 'describe'], 'type': 'string'}, 'standard': {'description': 'The standard to audit against: brand guidelines, compliance policy, naming convention, or internal quality standard.', 'type': 'string'}}, "required": ["operation"], }, } super().__init__(self.name, self.metadata) # ── helpers ───────────────────────────────────────────────────────── def _subject(self, kwargs): for key in ("subject", "input", "target", "topic"): value = str(kwargs.get(key) or "").strip() if value: return value return "" def _header(self, subject): label = subject or f"" return f"{_SPEC['verb']}: {label}" def _context(self, kwargs): extras = [] for key in _SPEC["params"]: if key == "subject": continue value = str(kwargs.get(key) or "").strip() if value: extras.append(f"{key}: {value}") return extras def _plan(self, subject, kwargs): lines = [self._header(subject)] extras = self._context(kwargs) if extras: lines += ["", "Context:"] + [f" {e}" for e in extras] lines += ["", "Procedure:"] lines += [f" {i}. {step}" for i, step in enumerate(_SPEC["steps"], 1)] if not subject: lines += [ "", f"Pass subject=\u0022...\u0022 to bind this procedure to a " f"specific {_SPEC['subject_label']}.", ] return lines def _checklist(self): return ["Acceptance checks:"] + [f" [ ] {c}" for c in _SPEC["checks"]] def _provenance(self): src = __manifest__["source"] lines = [ f"{__manifest__['display_name']} (v{__manifest__['version']})", "", __manifest__["description"], "", f"Capability shape: {_SPEC['archetype']} " f"(confidence {_SPEC['confidence']})", ] platforms = __manifest__.get("platforms") or [] if platforms: lines.append("Runs on: " + ", ".join(platforms)) lines += [ "", f"Indexed from: {src['source_name']}", f"Upstream entry: {src['upstream_url']}", f"Upstream author: {__manifest__['author']}", "", "RAR indexes this capability and implements its method; the " "upstream library remains the authority for its own instructions. " "Open the link above to get those from the source.", ] return lines # ── recipe entries: the upstream recipe, verbatim, deterministic ───── def _recipe_context(self, kwargs): extras = [] subject = self._subject(kwargs) if subject: extras.append(f"subject: {subject}") for key in _SPEC["params"]: value = str(kwargs.get(key) or "").strip() if value: extras.append(f"{key}: {value}") return extras def _recipe_prompt(self, kwargs): r = _SPEC["recipe"] lines = [r["prompt"]] extras = self._recipe_context(kwargs) if extras: lines += ["", "Context supplied by the caller:"] + [f"- {e}" for e in extras] return lines def _recipe_attribution(self): src = __manifest__["source"] r = _SPEC["recipe"] who = ", ".join(r.get("authors") or []) or __manifest__["author"] return [ f"Recipe: {__manifest__['display_name']} — by {who}, {src['source_name']} " f"({src['license']}). Source: {src['upstream_url']}", ] def _perform_recipe(self, op, kwargs): r = _SPEC["recipe"] ref = _SPEC.get("refinement") or {} if op == "prompt": return "\n".join(self._recipe_prompt(kwargs) + [""] + self._recipe_attribution()) if op == "plan": lines = [f"Steps for {__manifest__['display_name']} on {r['platform']}:"] lines += [f" {i}. {s}" for i, s in enumerate(r["steps"], 1)] return "\n".join(lines + [""] + self._recipe_attribution()) if op == "checklist": lines = ["Before you run it:"] + [f" [ ] {p}" for p in r["prerequisites"]] if r.get("expected_output"): lines += ["", "Done when:", f" [ ] {r['expected_output']}"] return "\n".join(lines + [""] + self._recipe_attribution()) if op == "describe": lines = self._provenance() if ref.get("when_to_use"): lines += ["", f"When to use: {ref['when_to_use']}"] if ref.get("example_request"): lines += [f"Ask for it like: {ref['example_request']}"] if ref.get("inputs"): lines += ["", "It will ask you for:"] + [f" - {i['name']}: {i['description']}" for i in ref["inputs"]] if r.get("business_value"): lines += ["", f"Why it matters: {r['business_value']}"] return "\n".join(lines) if op == "run": lines = [f"{__manifest__['display_name']} — run on {r['platform']}", ""] if r.get("what_it_does"): lines += [r["what_it_does"], ""] lines += [f"Prompt (paste into {r['platform']}):", ""] + self._recipe_prompt(kwargs) + [""] lines += ["Procedure:"] + [f" {i}. {s}" for i, s in enumerate(r["steps"], 1)] + [""] lines += ["Acceptance checks:"] + [f" [ ] {c}" for c in _SPEC["checks"]] + [""] lines += [f"Deliverable: {_SPEC['deliverable']}", ""] if r.get("tenant_caveat"): lines += [f"Verified upstream: {r['tenant_caveat']}", ""] return "\n".join(lines + self._recipe_attribution()) return ( f"Unknown operation {op!r}. Valid operations: " + ", ".join(_SPEC["operations"]) ) # ── entry point ───────────────────────────────────────────────────── def perform(self, **kwargs): """Run the toasted capability. Always returns a string.""" op = str(kwargs.get("operation") or "run").strip().lower() subject = self._subject(kwargs) if _SPEC.get("recipe"): return self._perform_recipe(op, kwargs) if op == "describe": return "\n".join(self._provenance()) if op == "checklist": return "\n".join([self._header(subject), ""] + self._checklist()) if op == "plan": return "\n".join(self._plan(subject, kwargs)) if op == "run": lines = self._plan(subject, kwargs) lines += [""] + self._checklist() lines += ["", f"Deliverable: {_SPEC['deliverable']}"] lines += ["", f"Source: {__manifest__['source']['upstream_url']}"] return "\n".join(lines) return ( f"Unknown operation {op!r}. Valid operations: " + ", ".join(_SPEC["operations"]) ) if __name__ == "__main__": print(AuditAndSurfaceAgainstAStandard().perform(operation="run")) ```