Imported from kody-w/RAR (
scout/bundles/cowork-cookbook-131/skills/rar-cowork-cookbook-report-analyze-costs/SKILL.md). Install upstream withnpx skills add kody-w/RAR --skill rar-cowork-cookbook-report-analyze-costs. Copyright stays with the author.
Microsoft Scout runtime
This is the reversible Scout projection of @cowork-cookbook/report_analyze_costs. The original RAPP
agent is preserved byte-for-byte in report_analyze_costs_agent.py and in the RCI capsule.
When Scout can execute local files, resolve this skill directory and run:
python3 scripts/run_agent.py --preflight
echo '{}' | python3 scripts/run_agent.pyPass 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.
Analyze costs Summary Report — Builds a structured summary report of analyze costs activity with totals, trends, and breakdowns.
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.
Nothing from upstream is reproduced here. What runs below is RAR's own method for this shape of work — a analyze capability — generated from the metadata we index. The upstream library remains the authority for its own instructions; this agent is callable on its own terms and links home for the source.
Source library : Cowork Cookbook (Sean Galliher and Cowork Cookbook contributors) Upstream entry : https://coworkcookbook.com/recipes/report-analyze-costs 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):
{
"properties": {
"data_source": {
"description": "Optional. Where the evidence comes from.",
"type": "string"
},
"operation": {
"description": "What to do: run, plan, checklist, describe.",
"enum": [
"run",
"plan",
"checklist",
"describe"
],
"type": "string"
},
"subject": {
"description": "The question to answer, stated as a question.",
"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 report_analyze_costs_agent.py and embedded as the fenced Python below (sha256 09304482f1e5cf85…; 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 report_analyze_costs_agent.py first:
python3 report_analyze_costs_agent.py '{"key": "value"}' # arguments as one JSON object
echo '{"key": "value"}' | python3 report_analyze_costs_agent.py # or on stdin
python3 report_analyze_costs_agent.py --tool # emit the JSON tool contractTreat 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.
"""
Analyze costs Summary Report — Builds a structured summary report of analyze costs activity with totals, trends, and breakdowns.
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.
Nothing from upstream is reproduced here. What runs below is RAR's own method
for this shape of work — a analyze capability — generated from the metadata
we index. The upstream library remains the authority for its own instructions;
this agent is callable on its own terms and links home for the source.
Source library : Cowork Cookbook (Sean Galliher and Cowork Cookbook contributors)
Upstream entry : https://coworkcookbook.com/recipes/report-analyze-costs
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/report_analyze_costs',
"version": '2.0.0',
"display_name": 'Analyze costs Summary Report',
"description": 'Builds a structured summary report of analyze costs activity with totals, trends, and breakdowns.',
"author": 'Sean Galliher and Cowork Cookbook contributors',
"tags": ['industry_solution', 'business_process', 'prompt', 'report', 'record_to_report', 'intermediate', 'integration', 'dynamics_365_erp'],
"category": 'integrations',
"quality_tier": 'verified',
"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": 'report-analyze-costs',
"upstream_url": 'https://coworkcookbook.com/recipes/report-analyze-costs',
"upstream_version": '1.0.0',
"license": 'CC-BY-4.0',
"license_verified": True,
"details": {'license_note': 'Recipe content is CC BY 4.0 and code is MIT. RAR remains index-only: it stores normalized metadata and attribution, then generates its own callable method from that metadata without copying recipe prompts or bundles.', '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": '048771d92f5e8cb5',
},
"industry_context": {'deprecated': False, 'difficulty': 'intermediate', 'last_verified_on': '2026-05-25', 'mutates_data': False, 'plugin': 'dynamics-365-erp', 'process_roots': ['record-to-report'], 'process_tags': ['record-to-report/analyze-financial-performance/analyze-costs'], 'recipe_category': 'report', 'recipe_type': 'prompt', 'upstream_path': 'record-to-report/report-analyze-costs', 'uses_skills': {'custom': [], 'ootb': ['Excel'], 'plugin': [{'action': 'data_find_entity_type', 'plugin': 'dynamics-365-erp'}, {'action': 'data_find_entities_sql', 'plugin': 'dynamics-365-erp'}]}, 'verification_status': 'verified'},
# 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. The upstream entry supplies the WHAT; this procedure
# is RAR's own method for that shape of work, generated by
# @kody-w/skill_toaster_agent from the metadata we hold. No upstream text is
# reproduced here — see the module docstring.
_SPEC = {'archetype': 'analyze', 'checks': ['The question is falsifiable and answered directly.', 'The decision threshold was stated before the result.', 'Missing evidence is named rather than silently excluded.', 'Uncertainty is quantified.'], 'confidence': 0.429, 'deliverable': 'A decision-grade answer: one-sentence verdict, method, evidence, uncertainty, and what would change the conclusion.', 'operations': ['run', 'plan', 'checklist', 'describe'], 'params': {'data_source': 'Optional. Where the evidence comes from.', 'subject': 'The question to answer, stated as a question.'}, 'refined_by': 'rules', 'signals': ['tag:analysis', 'word:analyze'], 'steps': ["Restate the question so it is falsifiable. 'Is X better?' becomes 'Does X reduce Y by more than Z?'", 'Declare in advance what result would change the decision — this is what separates analysis from justification.', 'Identify the evidence available and, explicitly, the evidence that is missing.', 'Compute the comparison, holding the method constant across every option.', 'Quantify uncertainty. A point estimate with no interval invites false confidence.', 'Answer the original question in one sentence, then show the working beneath it.'], 'subject_label': 'question under analysis', 'verb': 'Analyze'}
class ReportAnalyzeCosts(BasicAgent):
"""Analyze agent, toasted from an aggregated upstream entry."""
def __init__(self):
self.name = 'ReportAnalyzeCosts'
self.metadata = {
"name": self.name,
"display_name": __manifest__["display_name"],
"description": __manifest__["description"],
"parameters": {
"type": "object",
"properties": {'data_source': {'description': 'Optional. Where the evidence comes from.', 'type': 'string'}, 'operation': {'description': 'What to do: run, plan, checklist, describe.', 'enum': ['run', 'plan', 'checklist', 'describe'], 'type': 'string'}, 'subject': {'description': 'The question to answer, stated as a question.', '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"<no {_SPEC['subject_label']} supplied>"
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
# ── 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 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(ReportAnalyzeCosts().perform(operation="run"))