Imported from kody-w/rapp-monorepo (
repos/RAR/scout/bundles/cowork-cookbook-72/skills/rar-cowork-cookbook-d365-concept-to-market/SKILL.md). Install upstream withnpx skills add kody-w/rapp-monorepo --skill rar-cowork-cookbook-d365-concept-to-market. Copyright stays with the author.
Microsoft Scout runtime
This is the reversible Scout projection of @cowork-cookbook/d365_concept_to_market. The original RAPP
agent is preserved byte-for-byte in d365_concept_to_market_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.
D365 Concept to market Expert — A Dynamics 365 Finance & Supply Chain Management expert scoped to the Concept to market end-to-end process - covers 6 L2 areas and 31 L3 processes from the Microsoft Business Process Catalog.
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 automate 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/d365-concept-to-market 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": {
"operation": {
"description": "What to do: run, plan, checklist, describe.",
"enum": [
"run",
"plan",
"checklist",
"describe"
],
"type": "string"
},
"subject": {
"description": "The process to automate.",
"type": "string"
},
"trigger": {
"description": "Optional. What starts it \u2014 schedule, event or manual.",
"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 d365_concept_to_market_agent.py and embedded as the fenced Python below (sha256 2b60df5c23ae412b…; 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 d365_concept_to_market_agent.py first:
python3 d365_concept_to_market_agent.py '{"key": "value"}' # arguments as one JSON object
echo '{"key": "value"}' | python3 d365_concept_to_market_agent.py # or on stdin
python3 d365_concept_to_market_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.
"""
D365 Concept to market Expert — A Dynamics 365 Finance & Supply Chain Management expert scoped to the Concept to market end-to-end process - covers 6 L2 areas and 31 L3 processes from the Microsoft Business Process Catalog.
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 automate 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/d365-concept-to-market
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/d365_concept_to_market',
"version": '2.0.0',
"display_name": 'D365 Concept to market Expert',
"description": 'A Dynamics 365 Finance & Supply Chain Management expert scoped to the Concept to market end-to-end process - covers 6 L2 areas and 31 L3 processes from the Microsoft Business Process Catalog.',
"author": 'Sean Galliher and Cowork Cookbook contributors',
"tags": ['industry_solution', 'business_process', 'prompt_skill', 'other', 'concept_to_market', '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": 'd365-concept-to-market',
"upstream_url": 'https://coworkcookbook.com/recipes/d365-concept-to-market',
"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": '97e5339c8e1227b5',
},
"industry_context": {'deprecated': False, 'difficulty': 'intermediate', 'last_verified_on': '2026-05-24', 'mutates_data': False, 'plugin': 'dynamics-365-erp', 'process_roots': ['concept-to-market'], 'process_tags': ['concept-to-market'], 'recipe_category': 'other', 'recipe_type': 'prompt+skill', 'upstream_path': 'concept-to-market/d365-concept-to-market', 'uses_skills': {'custom': ['d365-concept-to-market'], 'ootb': [], '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': 'automate', 'checks': ['Every step is idempotent and the whole run is safely retryable.', 'Failure behaviour is defined per step, and failures are loud.', 'A completion condition exists and is checked.', 'The first production run was reconciled against the manual process.'], 'confidence': 1.0, 'deliverable': 'A runnable automation with a defined trigger, per-step failure policy, an observable signal, and a reconciliation against the manual process.', 'operations': ['run', 'plan', 'checklist', 'describe'], 'params': {'subject': 'The process to automate.', 'trigger': 'Optional. What starts it — schedule, event or manual.'}, 'refined_by': 'rules', 'signals': ['tag:integration'], 'steps': ['Run the process manually once and write down every step, including the ones people do without noticing.', 'Identify the trigger and the completion condition. An automation with no defined end does not terminate, it accumulates.', 'Make each step idempotent, so a retry is safe and a partial run can be resumed rather than restarted.', 'Decide failure behaviour per step: retry, skip, or halt. Silent failure is the expensive one.', 'Add an observable signal — a log line, a status file, a notification — so a broken run is noticed without being looked for.', 'Run it alongside the manual process until they agree, then retire the manual path deliberately.'], 'subject_label': 'process to automate', 'verb': 'Automate'}
class D365ConceptToMarket(BasicAgent):
"""Automate agent, toasted from an aggregated upstream entry."""
def __init__(self):
self.name = 'D365ConceptToMarket'
self.metadata = {
"name": self.name,
"display_name": __manifest__["display_name"],
"description": __manifest__["description"],
"parameters": {
"type": "object",
"properties": {'operation': {'description': 'What to do: run, plan, checklist, describe.', 'enum': ['run', 'plan', 'checklist', 'describe'], 'type': 'string'}, 'subject': {'description': 'The process to automate.', 'type': 'string'}, 'trigger': {'description': 'Optional. What starts it — schedule, event or manual.', '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(D365ConceptToMarket().perform(operation="run"))