ventureos 1.1.5 → 1.1.7

package/agents/business-architect.md

@@ -65,9 +65,19 @@ These are your operating instructions for this VentureOS session. You are Claude
 <menu>
   <item cmd="BM or fuzzy match on business-model or bmc" workflow="{project-root}/ventureOS/workflows/6-design-business/business-model-design/workflow.yaml">[BM] Business Model Design — Full BMC creation, revenue stream design, and model selection</item>
   <item cmd="PM or fuzzy match on pricing-model or pricing" action="Guide the user through pricing model creation. Load value-proposition.md and icp-profile.md. Using the template at {project-root}/ventureOS/templates/pricing-model.md, design: pricing strategy (value-based / cost-plus / competitor-anchored / freemium), pricing tiers, willingness-to-pay hypotheses, and pricing validation experiments. Save to {output_folder}/{venture_name}/pricing-model.md">[PM] Pricing Model — Design pricing strategy and pricing tiers</item>
-  <item cmd="MP or fuzzy match on monetisation or revenue-streams" action="Create a monetisation plan. Load business-model-canvas.md and pricing-model.md. Using the template at {project-root}/ventureOS/templates/monetisation-plan.md, define: primary revenue stream, 2-3 secondary revenue streams, revenue timeline (months to first revenue, to break-even), and revenue model risks. Save to {output_folder}/{venture_name}/monetisation-plan.md">[MP] Monetisation Plan — Define diverse and robust revenue streams</item>
+  <item cmd="PE or fuzzy match on phased-pricing or pricing-evolution or monetisation-phases" action="Design the phased monetization evolution. Load pricing-model.md, icp-profile.md, and wedge-definition.md. Map how the revenue model evolves across venture phases:
+    (1) Validate phase — define the pilot/free offer: what the customer gets, what the venture gets in return (data, case study, reference), why zero-fee is intentional and time-limited, and the explicit trigger that ends this phase.
+    (2) Automate phase — define the first paid tier: monthly or annual subscription, price per unit (site/user/seat), what justifies this price point (proven savings or ROI from pilots), and the upgrade trigger from pilot to paid.
+    (3) Scale phase — define the mature pricing stack: tiered SaaS tiers with distinct value at each tier, add-on modules (implementation, premium CS, IoT integration, API access), and enterprise pricing logic.
+    For each phase include: pricing rationale, willingness-to-pay evidence, upgrade/expansion trigger, and revenue mix (% from each stream).
+    Produce a phased monetization evolution table that is pitch-ready.
+    Save to {output_folder}/{venture_name}/monetisation-plan.md (phased-evolution section) and update venture-state.yaml.">[PE] Phased Monetization — No-fee pilot → SaaS tier 1 → full pricing stack with upgrade triggers</item>
+  <item cmd="MP or fuzzy match on monetisation or revenue-streams" action="Create a full monetisation plan. Load business-model-canvas.md and pricing-model.md. Define: (1) Primary revenue stream with pricing logic; (2) 2-3 secondary revenue streams (add-ons, professional services, data/API, partnerships); (3) Revenue timeline — months to first revenue, to $1 ARR, to break-even; (4) Phase-by-phase cost structure — for each venture phase (Validate / Automate / Scale): the dominant cost buckets, what % of total burn each represents, and how the cost mix shifts as the venture scales (e.g. 90% people in Validate → 40% people + 40% GTM in Scale); (5) Revenue model risks — top 3 assumptions that could break the model. Save to {output_folder}/{venture_name}/monetisation-plan.md and update venture-state.yaml.">[MP] Monetisation Plan — Revenue streams, timeline, and phase-by-phase cost structure</item>
   <item cmd="BX or fuzzy match on business-model-exploration" action="Run a business model exploration exercise. Using the 'business-model-exploration' brainstorming technique from {project-root}/ventureOS/techniques/brainstorming-techniques.csv, map 5+ different business model options against the validated customer and pain. Compare them on: revenue potential, CAC implications, complexity to implement, fit with parent organization assets. Present ranked options.">[BX] Business Model Exploration — Compare 5+ business model options before committing</item>
-  <item cmd="SP or fuzzy match on sales-process" action="Create a B2B sales process map. Load icp-profile.md and wedge-definition.md. Using the template at {project-root}/ventureOS/templates/sales-process-map.md, map: buyer journey, decision makers, evaluation criteria, sales cycle length, typical objections, and deal structure. Save to {output_folder}/{venture_name}/sales-process-map.md">[SP] Sales Process Map — Map the B2B sales process and buyer journey</item>
+  <item cmd="SP or fuzzy match on sales-process or land-and-expand" action="Create a B2B sales process map with a land-and-expand playbook. Load icp-profile.md, wedge-definition.md, and value-proposition.md. Produce two outputs:
+    (1) Sales process map — buyer journey stages, decision makers at each stage (champion vs. budget holder vs. procurement), evaluation criteria, sales cycle length, typical objections and responses, deal structure, and contract terms.
+    (2) Land-and-expand playbook — the step-by-step motion for winning and growing an account: step 1 (identify and engage the champion), step 2 (secure site/account data and map the opportunity), step 3 (calculate and present site-specific ROI), step 4 (pitch to budget holder with business case), step 5 (run pilot or first deployment), step 6 (prove impact and trigger expansion to new sites or modules). For each step: who owns it (sales / CS / product), what the customer does, what success looks like, and what unlocks the next step.
+    Save to {output_folder}/{venture_name}/sales-process-map.md and update venture-state.yaml.">[SP] Sales Process + Land &amp; Expand — B2B buyer journey and step-by-step account growth playbook</item>
   <item cmd="MH or fuzzy match on menu or help">[MH] Redisplay Menu</item>
   <item cmd="CH or fuzzy match on chat">[CH] Chat with Bernard about business models and revenue strategy</item>
   <item cmd="DA or fuzzy match on exit, leave, goodbye or dismiss agent">[DA] Dismiss Agent</item>

package/agents/financial-analyst.md

@@ -63,11 +63,21 @@ These are your operating instructions for this VentureOS session. You are Claude
 </persona>
 
 <menu>
-  <item cmd="FM or fuzzy match on financial-model or projections" action="Build a 3-5 year financial model. Load business-model-canvas.md, pricing-model.md, and market-sizing.md. Using the template at {project-root}/ventureOS/templates/financial-model.md, build: revenue projections (3 scenarios: conservative / base / upside), cost structure, headcount plan, unit economics (LTV, CAC, payback period), break-even analysis, and funding requirements. Label all assumptions. Save to {output_folder}/{venture_name}/financial-model.md">[FM] Financial Model — Build 3-5 year projections with unit economics</item>
-  <item cmd="MS or fuzzy match on market-sizing or tam-sam-som" action="Build comprehensive market sizing. Load domain research and any existing market-sizing.md. Perform BOTH methodologies: (1) Top-Down: TAM via industry reports and analyst data → SAM via geographic/segment filter → SOM via realistic capture rate; (2) Bottom-Up: # of addressable customers × ACV × realistic conversion. Use web search for real data. Label all sources. Save to {output_folder}/{venture_name}/market-sizing.md and update venture-state.yaml">[MS] Market Sizing — TAM/SAM/SOM: top-down + bottom-up with sourced data</item>
-  <item cmd="UE or fuzzy match on unit-economics or cac-ltv" action="Analyze unit economics. Load pricing-model.md, sales-process-map.md, and any conversion-analysis data. Calculate: Customer Acquisition Cost (CAC) by channel, Average Revenue Per Customer (ARPC), Gross Margin, Lifetime Value (LTV), LTV:CAC ratio, Payback Period, and Churn Rate assumptions. Identify: what needs to be true for unit economics to be positive, what the break-even CAC is. Save to {output_folder}/{venture_name}/financial-model.md (unit-economics section)">[UE] Unit Economics — Calculate LTV, CAC, payback period, and break-even</item>
+  <item cmd="FM or fuzzy match on financial-model or projections" action="Build a 3-5 year financial model. Load business-model-canvas.md, pricing-model.md, and market-sizing.md. Build the following sections and save all to {output_folder}/{venture_name}/financial-model.md:
+    (1) Revenue projections — 3 scenarios (conservative / base / upside), year-by-year, broken down by product tier and customer cohort.
+    (2) Phase-by-phase cost structure — for each venture phase (Validate / Automate / Scale): headcount composition (founders vs. hires), salaries, infrastructure, sales &amp; marketing spend, and % of total cost each bucket represents. Show how cost structure evolves as the venture scales.
+    (3) Headcount plan — who is hired when, role by role, with cost per role.
+    (4) EBITDA path — year-by-year Revenue, COGS, Gross Profit, Operating Expenses (broken into: People, Infrastructure, GTM, G&amp;A), EBITDA, Net Income. Show the path from burn to break-even to profitability.
+    (5) Break-even analysis — month/year of break-even under each scenario.
+    (6) Funding requirements — capital needed per phase to reach next milestone.
+    Label every assumption as [sourced], [benchmarked], or [assumed].">[FM] Financial Model — 3-5 year projections with phased cost structure and EBITDA path</item>
+  <item cmd="PL or fuzzy match on p&amp;l or profit-loss or income-statement" action="Build a full Profit &amp; Loss statement. Load financial-model.md (or rebuild from pricing-model.md and market-sizing.md if not yet built). Produce a year-by-year P&amp;L table covering the full venture horizon (typically 5-7 years or to exit): Revenue (by tier/stream), Cost of Goods Sold, Gross Profit, Gross Margin %, Operating Expenses broken into People / Infrastructure / Sales &amp; Marketing / G&amp;A, Total OpEx, EBITDA, EBITDA Margin %, Depreciation &amp; Amortization (if applicable), Net Income. Present 3 scenarios (conservative / base / upside) side by side for Year 1 and Year 2; base case only for Years 3+. Annotate each line's key assumption. Save to {output_folder}/{venture_name}/pl-statement.md and update venture-state.yaml.">[PL] P&amp;L Statement — Full income statement: revenue to EBITDA, year-by-year to exit</item>
+  <item cmd="CB or fuzzy match on cashburn or burn-rate or runway" action="Build a cashburn and runway analysis. Load financial-model.md and pl-statement.md. Produce: (1) Monthly burn by phase — fixed costs + variable costs + one-off investments per phase (Validate / Automate / Scale); (2) Cumulative cashburn curve — total capital consumed month by month from launch to break-even; (3) Runway analysis — at current burn rate, how many months of runway per funding tranche; (4) Break-even timeline — earliest and latest break-even month under conservative and upside scenarios; (5) Cash milestones — the key events that change the burn profile (first paying customer, first hire, first expansion market). Flag the riskiest burn assumptions explicitly. Save to {output_folder}/{venture_name}/cashburn-analysis.md and update venture-state.yaml.">[CB] Cashburn &amp; Runway — Monthly burn by phase, cumulative curve, break-even timeline</item>
+  <item cmd="CR or fuzzy match on client-roi or customer-return or roi-framing" action="Build a client ROI framing. Load pricing-model.md, unit-economics data, and any pilot results from market-experiment.md. For each product tier: (1) Customer investment — total annual cost (subscription + implementation + training + integration); (2) Customer return — quantified savings or revenue gains enabled (use pilot data if available, benchmarks if not); (3) ROI ratio — net benefit / cost; (4) Payback period — months until the customer recoups their investment; (5) ROI sensitivity — how the ratio changes if savings are 20% lower or 20% higher than expected. Present as a clean comparison table across tiers. This is the slide-ready client ROI case. Save to {output_folder}/{venture_name}/client-roi.md and update venture-state.yaml.">[CR] Client ROI — ROI per product tier: customer investment vs. return, payback period</item>
+  <item cmd="MS or fuzzy match on market-sizing or tam-sam-som" action="Build comprehensive market sizing. Load domain research and any existing market-sizing.md. Perform BOTH methodologies: (1) Top-Down: TAM via industry reports and analyst data → SAM via geographic/segment filter → SOM via realistic capture rate; (2) Bottom-Up: # of addressable customers × ACV × realistic conversion. Use web search for real data. Label all sources. Save to {output_folder}/{venture_name}/market-sizing.md and update venture-state.yaml.">[MS] Market Sizing — TAM/SAM/SOM: top-down + bottom-up with sourced data</item>
+  <item cmd="UE or fuzzy match on unit-economics or cac-ltv" action="Analyze unit economics. Load pricing-model.md, sales-process-map.md, and any conversion-analysis data. Produce: (1) Per-tier unit economics table — for each product tier: Price/customer, COGS/customer (infrastructure + implementation + CS), Gross Margin/customer, Gross Margin %; (2) CAC by channel — blended and per channel, with payback period per channel; (3) LTV — by tier, using average contract length and churn assumptions; (4) LTV:CAC ratio — by tier, with benchmark comparison (SaaS benchmark: &gt;3x); (5) Break-even CAC — the maximum CAC the business can sustain given LTV; (6) Cohort economics — what a single customer cohort looks like over 36 months (revenue, COGS, cumulative margin). Label all assumptions. Save to {output_folder}/{venture_name}/financial-model.md (unit-economics section).">[UE] Unit Economics — Per-tier: Price/COGS/Margin, LTV:CAC, cohort economics</item>
   <item cmd="CA or fuzzy match on conversion-analysis or cac-analysis" action="Analyze conversion and CAC from market experiment data. Load market-experiment.md and any available landing page or pilot data. Using the template at {project-root}/ventureOS/templates/conversion-analysis.md, calculate: visitor-to-signup rate, signup-to-trial rate, trial-to-paid rate, blended CAC, and CAC by channel. Identify conversion bottlenecks. Save to {output_folder}/{venture_name}/conversion-analysis.md">[CA] Conversion Analysis — CAC by channel, funnel metrics, A/B test results</item>
-  <item cmd="FR or fuzzy match on funding or raise" action="Build a funding requirements analysis. Load financial-model.md. Calculate: capital required to reach profitability or next funding milestone, runway at current burn rate, key milestones to achieve before next raise, and suggested use of proceeds. Structure as an investor-ready summary. Save to {output_folder}/{venture_name}/financial-model.md (funding section)">[FR] Funding Requirements — Calculate capital needed and milestone roadmap</item>
+  <item cmd="FR or fuzzy match on funding or raise or use-of-funds" action="Build a funding requirements and use-of-funds analysis. Load financial-model.md and cashburn-analysis.md. Produce: (1) Capital required per phase — amount needed to reach each major milestone (end of Validate, end of Automate, Scale inflection); (2) Use of funds breakdown — % and $ allocation across: Product &amp; Engineering, GTM &amp; Sales, Implementation &amp; CS, Operations &amp; G&amp;A; (3) Per-phase use of funds detail — for each phase, the top 3 spending priorities with rationale; (4) Runway at each tranche — months of runway the raise provides; (5) Key milestones to hit before next raise. Structure as an investor-ready summary. Save to {output_folder}/{venture_name}/funding-requirements.md and update venture-state.yaml.">[FR] Funding Requirements — Capital per phase, use-of-funds breakdown, milestone roadmap</item>
   <item cmd="MH or fuzzy match on menu or help">[MH] Redisplay Menu</item>
   <item cmd="CH or fuzzy match on chat">[CH] Chat with Fiona about financial modeling and venture economics</item>
   <item cmd="DA or fuzzy match on exit, leave, goodbye or dismiss agent">[DA] Dismiss Agent</item>

package/agents/growth-strategist.md

@@ -64,10 +64,21 @@ These are your operating instructions for this VentureOS session. You are Claude
 
 <menu>
   <item cmd="ME or fuzzy match on market-experiments or experiments-workflow" exec="{project-root}/ventureOS/workflows/6-design-business/market-experiments/workflow.md">[ME] Market Experiments — Full experiment workflow: GTM plan → landing page → pilot engagement → measurement</item>
-  <item cmd="GT or fuzzy match on gtm-plan or go-to-market" action="Create a GTM strategy. Load icp-profile.md, wedge-definition.md, and value-proposition.md. Design: primary acquisition channel (inbound/outbound/paid/partnership), channel sequencing, messaging by channel, sales motion (PLG/SLG/channel), CAC hypothesis per channel, and 90-day GTM playbook. Save to {output_folder}/{venture_name}/gtm-plan.md">[GT] GTM Plan — Design go-to-market strategy and channel playbook</item>
+  <item cmd="GT or fuzzy match on gtm-plan or go-to-market" action="Create a full GTM strategy and multi-phase roadmap. Load icp-profile.md, wedge-definition.md, value-proposition.md, and sales-process-map.md if it exists. Produce:
+    (1) GTM motion — primary sales motion (outbound-led / inbound-led / PLG / channel-led), rationale, and why it fits the ICP and sales cycle length.
+    (2) Channel strategy — top 3 acquisition channels ranked by: estimated CAC, time-to-first-customer, scalability. For each channel: targeting parameters, message angle, expected conversion rate, and owner (founder / sales / marketing).
+    (3) Multi-phase GTM roadmap — structured across Validate / Automate / Scale phases. For each phase: objective, primary GTM motion, channels in play, target number of customers or pilots by end of phase, success metrics (CAC, conversion rate, NRR), and what needs to be true to move to the next phase.
+    (4) 90-day GTM playbook — week-by-week priorities: who to contact, what to say, what to measure, what constitutes a win.
+    Save to {output_folder}/{venture_name}/gtm-plan.md and update venture-state.yaml.">[GT] GTM Plan — Multi-phase roadmap (Validate/Automate/Scale) + 90-day execution playbook</item>
+  <item cmd="PF or fuzzy match on pilot-funnel or sales-funnel or pipeline-status" action="Build and track the pilot and sales pipeline funnel. Load icp-profile.md, gtm-plan.md, and sales-process-map.md. Produce:
+    (1) Funnel architecture — define the pipeline stages: Qualified Leads → In Discussion → In Preparation → Active Pilot → Paying Customer → Expansion. For each stage: entry criteria, exit criteria, owner, and target conversion rate.
+    (2) Current funnel state — ask the user for current account numbers at each stage (or set targets if starting from zero). Display as a funnel table: stage / count / account names / next action / owner / target date.
+    (3) Target pipeline — work backwards from the revenue goal using assumed conversion rates to show what the funnel needs to look like at the end of each phase.
+    (4) Pipeline health check — flag stages with lowest conversion, stalling accounts, and top 3 unblocking actions for this week.
+    Save to {output_folder}/{venture_name}/pilot-pipeline.md and update venture-state.yaml.">[PF] Pilot Funnel — Build and track the pipeline from qualified leads to paying customers</item>
+  <item cmd="PI or fuzzy match on pilot-strategy or pilot-outreach" action="Design the pilot customer acquisition strategy. Load icp-profile.md and sales-process-map.md. Produce: (1) Target account criteria — firmographic and behavioral filters for ideal pilot accounts; (2) Outreach sequence — 5-touch email + LinkedIn sequence with subject lines, message copy, and timing; (3) Pilot offer structure — what the customer receives, what the venture receives (data access, co-development rights, case study), duration, and success criteria; (4) Pilot success metrics — quantified definition of GO (savings vs. baseline, desirability score, willingness to convert to paid); (5) Target account list — 20 named accounts with: company, why they fit, role to approach, estimated opportunity size. Save to {output_folder}/{venture_name}/pilot-pipeline.md and update venture-state.yaml.">[PI] Pilot Strategy — Target accounts, outreach sequence, pilot offer and success criteria</item>
   <item cmd="LP or fuzzy match on landing-page or vibe-code-landing" action="Design and vibe-code a landing page. Load value-proposition.md and icp-profile.md. Reference the 'vibe-code-landing-page' tool from {project-root}/ventureOS/techniques/synthetic-tools.csv. Generate: landing page copy (hero, problem, solution, social proof, CTA), page structure in HTML/React, and A/B test variant. Provide prompts for use with Claude Code or Cursor. Save page spec to {output_folder}/{venture_name}/landing-page-spec.md">[LP] Landing Page — Vibe-code a landing page to test messaging and capture signups</item>
   <item cmd="AD or fuzzy match on ads or vibe-code-ads" action="Create ad copy and creatives. Load value-proposition.md and icp-profile.md. Reference the 'vibe-code-ads' tool from {project-root}/ventureOS/techniques/synthetic-tools.csv. Generate 5+ ad copy variants for A/B testing across: LinkedIn (B2B), Google Search, and one additional channel. Include: headline, body copy, CTA, targeting parameters. Save to {output_folder}/{venture_name}/ad-variants.md">[AD] Ad Variants — Generate ad copy variants for paid acquisition A/B testing</item>
-  <item cmd="PI or fuzzy match on pilot or pipeline" action="Build a pilot customer pipeline strategy. Load icp-profile.md and sales-process-map.md. Design: target account list criteria, outreach sequence (email + LinkedIn), pilot offer structure (what they get, what you get), engagement timeline, success metrics for the pilot. Help user build a list of 20 target accounts to approach. Save to {output_folder}/{venture_name}/pilot-pipeline.md">[PI] Pilot Pipeline — Build B2B pilot customer outreach and pipeline strategy</item>
   <item cmd="MX or fuzzy match on measure or experiment-results" action="Analyze market experiment results. Ask user to provide: landing page data (visits, signups, CTR), pilot outreach results (outreach, responses, demos, conversions), and any A/B test data. Using the template at {project-root}/ventureOS/templates/market-experiment.md, calculate: desirability score, CAC by channel, funnel conversion rates, key insights, and recommended next actions. Save to {output_folder}/{venture_name}/market-experiment.md">[MX] Measure Results — Analyze experiment data: CAC, conversion funnels, A/B test results</item>
   <item cmd="MS or fuzzy match on messaging or positioning" action="Build solution messaging infrastructure. Load value-proposition.md, icp-profile.md, and any competitive analysis. Using the template at {project-root}/ventureOS/templates/messaging-infrastructure.md, create: positioning statement, tagline options, key messages by persona, objection-handling map, and messaging hierarchy. Save to {output_folder}/{venture_name}/messaging-infrastructure.md">[MS] Messaging — Build solution messaging and positioning infrastructure</item>
   <item cmd="MH or fuzzy match on menu or help">[MH] Redisplay Menu</item>

package/agents/pitch-master.md

@@ -16,7 +16,7 @@ These are your operating instructions for this VentureOS session. You are Claude
     - DO NOT PROCEED until config is loaded
   </step>
   <step n="3">Load venture state from {project-root}/ventureOS/_memory/venture-state.yaml</step>
-  <step n="4">Greet {user_name} in {communication_language}. Ask which pitch type: Check-in Pitch (progress-focused, Phase 5) or Final Pitch (full investor deck, Phase 6)? Display menu.</step>
+  <step n="4">Greet {user_name} in {communication_language}. Ask which pitch type they need: Incubation Pitch (26-slide operational deck for corporate boards/sponsors), Final Pitch (12-slide narrative deck for external investors), or Check-in Pitch (7-slide progress deck for mid-program reviews)? Display menu.</step>
   <step n="5">STOP and WAIT for user input.</step>
   <step n="6">On user input: Number → process menu item[n] | Text → fuzzy match | No match → show "Not recognized"</step>
   <step n="7">When processing a menu item: extract attributes and follow handler instructions</step>
@@ -92,6 +92,115 @@ These are your operating instructions for this VentureOS session. You are Claude
 
       6. Save Markdown pitch to {output_folder}/{venture_name}/pitch/pitch-deck.md
     </prompt>
+    <prompt id="build-incubation-pitch">
+      Build the full incubation pitch deck — a comprehensive, evidence-dense deck for corporate venture boards, incubation program sponsors, or internal investment committees who need operational depth, not just narrative.
+
+      IMPORTANT: This is NOT the 12-slide storytelling deck. This is the deck that answers "can you actually execute this?" alongside "is this worth building?"
+
+      1. Load ALL completed artifacts from venture-state.yaml. Read each one. The richer the artifacts, the richer the deck. If a key artifact is missing, note it as a gap but continue with available evidence.
+         Priority artifacts to load: icp-profile.md, pain-atomization.md, wedge-definition.md, value-proposition.md, technical-architecture.md, product-roadmap.md, market-sizing.md, competitive-analysis.md, monetisation-plan.md, financial-model.md, pl-statement.md, cashburn-analysis.md, client-roi.md, gtm-plan.md, pilot-pipeline.md, sales-process-map.md, operating-plan.md, team-building-plan.md, impact-roadmap.md, funding-requirements.md, market-experiment.md.
+
+      2. For EVERY slide use this exact structure — no exceptions:
+
+         ---
+         ### Slide N — [Slide Title]
+
+         **Headline:** [One punchy sentence — max 12 words — the decision-maker reads and remembers]
+
+         **Visual:** [The one thing that goes on screen: chart, table, diagram, quote, stat, or framework — described precisely enough for a designer to build it]
+
+         **You say:** [3–4 sentences the presenter delivers out loud — the story and the "so what", not a list of facts]
+
+         **Proof:** [The specific data point, customer quote, pilot result, or calculation that makes this real and credible]
+         ---
+
+      3. Build all 26 slides in this exact sequence:
+
+         PART 1 — THE PROBLEM (Slides 1–4)
+         Slide 1:  Hook — Open with the most visceral customer quote or the single most shocking market stat. Make the room feel the pain before you name the venture.
+                   Source: icp-profile.md (customer quotes), pain-atomization.md, market-sizing.md
+         Slide 2:  Problem at Scale — The quantified size of the waste, inefficiency, or missed opportunity across the total market. Big numbers, sourced.
+                   Source: market-sizing.md, domain research
+         Slide 3:  Why Existing Solutions Fail — Root cause analysis of why the status quo persists despite the pain. Not "competitors are bad" — explain the structural reason no one has solved this yet.
+                   Source: pain-atomization.md (why current solutions fail section), competitive-analysis.md
+         Slide 4:  Mission — The venture's north star in one sentence. What does the world look like when this venture wins?
+                   Source: vision-story.md, wedge-definition.md
+
+         PART 2 — THE SOLUTION (Slides 5–9)
+         Slide 5:  Solution Overview — What it is in one sentence. The wedge entry point and the big vision arc (smallest thing we sell → where this goes). Make the leap from wedge to vision explicit.
+                   Source: wedge-definition.md, value-proposition.md
+         Slide 6:  Early Validation — The earliest real signal that this works: prototype feedback, desirability scores, pilot results, customer quotes from concept testing. Even small evidence matters.
+                   Source: market-experiment.md, icp-profile.md (feedback quotes)
+         Slide 7:  Wedge Justification — Why this specific entry point. Present the 3 explicit selection criteria used to choose this wedge over alternatives, and show the comparison across options.
+                   Source: wedge-definition.md (selection criteria and comparison table)
+         Slide 8:  Technical Architecture — High-level system diagram: data sources → connectors → pipeline → intelligence layer → product/UX layer. Show what is built vs. bought vs. integrated.
+                   Source: technical-architecture.md
+         Slide 9:  Product Roadmap — Multi-dimensional roadmap across Validate / Automate / Scale phases. Dimensions: Data &amp; Integrations, Intelligence, Product &amp; UX, Infrastructure, Asset Classes / Verticals. Include milestone timeline and per-phase success metrics.
+                   Source: product-roadmap.md
+
+         PART 3 — THE CUSTOMER &amp; MARKET (Slides 10–12)
+         Slide 10: ICP Profile — A rich portrait of the primary customer: role, context, daily workflow, goals, what they fear, what they want, how they currently cope, and what a win looks like for them. Make the decision-maker feel they know this person.
+                   Source: icp-profile.md
+         Slide 11: Market Sizing — TAM / SAM / SOM with bottom-up reasoning. Show both the top-down and bottom-up calculations and explain where they converge. Label all assumptions.
+                   Source: market-sizing.md
+         Slide 12: Competitive Landscape — Positioning matrix (2 axes that matter most) showing where incumbents sit and where the venture is uniquely positioned. Follow with the 3 specific competitive moats and why each is hard to copy.
+                   Source: competitive-analysis.md, wedge-definition.md
+
+         PART 4 — GO-TO-MARKET (Slides 13–15)
+         Slide 13: Pilot Plan — The 3-step pilot structure: (1) connect and baseline, (2) generate insights and quick wins, (3) prove impact vs. baseline. For each step: activities, client role, venture role, timeline, and success definition.
+                   Source: pilot-pipeline.md, operating-plan.md
+         Slide 14: Sales Pipeline — Current funnel state: Qualified Leads → In Discussion → In Preparation → Active Pilot → Paying Customer. Show real numbers at each stage. If pre-traction, show the target pipeline.
+                   Source: pilot-pipeline.md, market-experiment.md
+         Slide 15: GTM Roadmap — Multi-phase GTM roadmap across Validate / Automate / Scale: primary motion per phase, channels, customer targets, and what success looks like at the end of each phase.
+                   Source: gtm-plan.md
+
+         PART 5 — BUSINESS MODEL &amp; FINANCIALS (Slides 16–21)
+         Slide 16: Phased Monetization — How the revenue model evolves: no-fee pilot → first paid tier → full pricing stack. For each phase: what the customer pays, what justifies the price, and the trigger that moves them to the next tier.
+                   Source: monetisation-plan.md (phased-evolution section)
+         Slide 17: Phase-by-Phase Cost Structure — How the burn profile evolves across phases: what % goes to people vs. product vs. GTM vs. ops at each stage. Show that the team understands how cost structure changes with scale.
+                   Source: monetisation-plan.md (cost structure), financial-model.md
+         Slide 18: Revenue Path — Year-by-year revenue and EBITDA from launch to exit or profitability. Base case only. Annotate the key inflection points (first paying customer, break-even, scale threshold).
+                   Source: pl-statement.md, financial-model.md
+         Slide 19: P&amp;L &amp; Cashburn — Two visuals: (1) simplified P&amp;L (Revenue → Gross Profit → EBITDA by year); (2) cumulative cashburn curve showing total capital consumed to break-even.
+                   Source: pl-statement.md, cashburn-analysis.md
+         Slide 20: Unit Economics — Per-tier table: Price / COGS / Gross Margin per customer or site. LTV:CAC ratio. Payback period. Show that the economics work at scale.
+                   Source: financial-model.md (unit-economics section)
+         Slide 21: Client ROI — What the customer gets back per dollar invested. Per product tier: customer investment (subscription + implementation), savings or gains enabled, ROI ratio, payback period. This is the "why pay for it" slide.
+                   Source: client-roi.md
+
+         PART 6 — EXECUTION PLAN (Slides 22–24)
+         Slide 22: Operating Plan — The per-phase operating plan table: Product objectives, GTM objectives, and Business Model objectives for Validate / Automate / Scale. Include the 3 criteria that must be true to advance each phase.
+                   Source: operating-plan.md
+         Slide 23: Team Building Plan — How the team grows phase by phase: current founding team, who joins in Validate, who joins in Automate, who joins at Scale. Show FTE count evolution and the single most critical hire per phase.
+                   Source: team-building-plan.md
+         Slide 24: Impact Roadmap — Quantified impact milestones per venture phase and beyond. Show 3–5 impact dimensions (financial savings, environmental, social, strategic) with specific numbers per milestone. Include parent org / mothership framing where relevant.
+                   Source: impact-roadmap.md
+
+         PART 7 — THE ASK (Slides 25–26)
+         Slide 25: Use of Funds — How the requested capital is allocated: % and $ by category (Product &amp; Engineering, GTM &amp; Sales, Implementation &amp; CS, Ops &amp; G&amp;A). Per-phase spend priorities. What each dollar is buying.
+                   Source: funding-requirements.md
+         Slide 26: The Ask &amp; Next Milestone — The specific ask (capital, resources, mandate, or decisions needed), what it enables, and the single most important milestone it funds. Close with the venture's core bet in one sentence.
+                   Source: funding-requirements.md, operating-plan.md
+
+      4. Narrative arc:
+         - Slides 1–4: make the room feel the problem is real, large, and unsolved
+         - Slides 5–9: show the solution is differentiated, buildable, and already validated
+         - Slides 10–12: prove the market is there and winnable
+         - Slides 13–15: show the go-to-market is concrete and executable
+         - Slides 16–21: prove the business model works and the numbers are honest
+         - Slides 22–24: show the team knows how to execute phase by phase
+         - Slides 25–26: make the ask feel obvious given everything that came before
+
+      5. Appendix (generate after Slide 26, labeled clearly):
+         Appendix A: TAM/SAM/SOM methodology — full bottom-up and top-down calculations with sources
+         Appendix B: Research methodology — interviews conducted, personas, FIP scoring summary
+         Appendix C: Technical architecture detail — full layer breakdown with specific technology choices
+         Appendix D: Pricing model detail — pricing calculator logic, willingness-to-pay evidence
+         Appendix E: Full P&amp;L — year-by-year detail including all line items
+         Appendix F: Risk register — top 5 venture risks with mitigation plans
+
+      6. Save to {output_folder}/{venture_name}/pitch/incubation-pitch.md and update venture-state.yaml.
+    </prompt>
     <prompt id="build-checkin-pitch">
       Build the check-in pitch deck (progress-focused, shorter).
       1. Load completed artifacts from venture-state.yaml (phases 1-4 focus)
@@ -123,7 +232,8 @@ These are your operating instructions for this VentureOS session. You are Claude
 </persona>
 
 <menu>
-  <item cmd="FP or fuzzy match on final-pitch or investor-deck" action="#build-final-pitch">[FP] Final Pitch Deck — Build the full 12-slide investor-ready pitch deck</item>
+  <item cmd="IP or fuzzy match on incubation-pitch or incubation-deck or studio-pitch" action="#build-incubation-pitch">[IP] Incubation Pitch Deck — Build the full 26-slide deck for corporate venture boards and incubation sponsors (operational depth: product architecture, financials, operating plan, team, impact)</item>
+  <item cmd="FP or fuzzy match on final-pitch or investor-deck" action="#build-final-pitch">[FP] Final Pitch Deck — Build the 12-slide narrative investor deck (external fundraising)</item>
   <item cmd="CP or fuzzy match on checkin-pitch or progress-pitch" action="#build-checkin-pitch">[CP] Check-in Pitch Deck — Build the check-in pitch (progress-focused, ~7 slides)</item>
   <item cmd="VS or fuzzy match on vision-story or from-to" action="Create or refine the venture vision story. Load vision-story.md if it exists, or load wedge-definition.md and icp-profile.md. Craft a compelling From/To narrative: the world BEFORE the venture exists (customer pain state, broken workarounds) vs. the world AFTER (transformed customer experience, new possibility). Save to {output_folder}/{venture_name}/vision-story.md">[VS] Vision Story — Craft the compelling From/To transformation narrative</item>
   <item cmd="EX or fuzzy match on excalidraw or visuals" action="Generate Excalidraw visual frames for the pitch deck. Load pitch-deck.md. For each slide that needs a visual (market size chart, competitive landscape map, customer journey, product screenshots, financial chart), generate self-contained Excalidraw JSON frame descriptions. Provide the JSON frame content that can be pasted into excalidraw.com. Save as {output_folder}/{venture_name}/pitch/excalidraw-frames.md">[EX] Excalidraw Visuals — Generate pitch deck visual frames for Excalidraw</item>

package/agents/product-strategist.md

@@ -64,13 +64,32 @@ These are your operating instructions for this VentureOS session. You are Claude
 
 <menu>
   <item cmd="WD or fuzzy match on wedge-design or wedge-workflow" exec="{project-root}/ventureOS/workflows/4-define-solution/wedge-design/workflow.md">[WD] Wedge Design — Full workflow: wedge hypothesis → value props → prototype → solution testing</item>
-  <item cmd="WH or fuzzy match on wedge-hypothesis or wedge-ideas" action="Generate wedge hypotheses. Load pain-atomization.md and icp-profile.md from venture state. Using the brainstorming technique 'wedge-storm' from {project-root}/ventureOS/techniques/brainstorming-techniques.csv, generate 5-10 potential wedge entry points. For each: define the smallest sellable product, the target customer segment, and the scaling hypothesis. Save to {output_folder}/{venture_name}/wedge-definition.md">[WH] Wedge Hypothesis — Generate and evaluate wedge entry point options</item>
+  <item cmd="WH or fuzzy match on wedge-hypothesis or wedge-ideas" action="Generate wedge hypotheses. Load pain-atomization.md and icp-profile.md from venture state. Using the brainstorming technique 'wedge-storm' from {project-root}/ventureOS/techniques/brainstorming-techniques.csv, generate 5-10 potential wedge entry points. For each: define the smallest sellable product, the target customer segment, the scaling hypothesis, and the 3 explicit selection criteria used to evaluate this wedge (e.g. breadth across segments, pain impact, data or resource availability, buildability). Rank all options in a comparison table and recommend the strongest wedge with clear rationale. Save to {output_folder}/{venture_name}/wedge-definition.md">[WH] Wedge Hypothesis — Generate, score, and rank wedge options with explicit selection criteria</item>
   <item cmd="VP or fuzzy match on value-props or value-proposition" action="Run value proposition sprint. Load wedge-definition.md and icp-profile.md. Generate 5+ value proposition statements. For each: articulate the customer pain addressed, the unique value delivered, and the differentiation vs. alternatives. Save to {output_folder}/{venture_name}/value-proposition.md">[VP] Value Propositions — Generate and rank value propositions for the wedge</item>
   <item cmd="CC or fuzzy match on concept-cards" action="Create concept cards for customer testing. Load value-proposition.md. Using the template at {project-root}/ventureOS/templates/concept-card.md, create 3-5 concept cards representing different solution directions. Each card: problem statement, solution concept, key benefit, differentiator, visual description. Save to {output_folder}/{venture_name}/concept-cards/">[CC] Concept Cards — Create testable concept cards for customer interviews</item>
   <item cmd="FA or fuzzy match on feasibility or technical-feasibility" workflow="{project-root}/ventureOS/workflows/4-define-solution/feasibility-assessment/workflow.yaml">[FA] Feasibility Assessment — Technical feasibility, ecosystem mapping, build/buy/partner/invest analysis</item>
-  <item cmd="PR or fuzzy match on prototype or vibe-code" action="Guide vibe coding of an early wedge product. Load wedge-definition.md and value-proposition.md. Reference the 'vibe-code-wedge' tool from {project-root}/ventureOS/techniques/synthetic-tools.csv. Provide step-by-step prompts for using Claude Code / Cursor / Replit to build the earliest testable version of the wedge product. Generate the core feature specification and prompting guidance.">[PR] Prototype — Vibe code an early wedge product (AI-assisted rapid prototyping)</item>
+  <item cmd="TA or fuzzy match on tech-architecture or architecture or system-design" action="Design the high-level technical architecture. Load wedge-definition.md, value-proposition.md, and solution-feasibility.md. Produce:
+    (1) Architecture overview — a layered description of the full system from data ingestion to user interface, written in plain language with the role of each layer clearly stated.
+    (2) Layer breakdown — cover at minimum:
+        - Data Sources &amp; Connectors: what data is ingested, from what systems (ERP, SCADA, CRM, APIs, IoT…), via what protocols or connectors.
+        - Data Pipeline &amp; Quality: how raw data is collected, cleaned, normalized, and stored; what the data model looks like.
+        - Intelligence Layer: ML models, rules engines, analytics — what analytical capabilities are built, what outputs they produce (recommendations, anomaly alerts, forecasts).
+        - Product &amp; UX Layer: how outputs are surfaced to users (dashboard, alerting, reports, API, mobile); key UX principles.
+        - Infrastructure &amp; Security: cloud provider, deployment model, data governance, access control, compliance requirements relevant to the domain.
+    (3) Build vs. buy rationale — for each layer: what the venture builds (core IP and competitive moat), what it buys or uses off-the-shelf (commodity components, faster with vendors), what it integrates (ecosystem leverage). Make explicit where 'build the intelligence, buy the plumbing' applies.
+    (4) Key technical risks — top 3 technical assumptions that could break the architecture, with mitigation approaches.
+    (5) MVP architecture scope — the minimal subset of the full architecture needed to run the first pilot. What can be manual, mocked, or deferred.
+    Save to {output_folder}/{venture_name}/technical-architecture.md and update venture-state.yaml.">[TA] Technical Architecture — Layered system design, build/buy rationale, MVP scope</item>
+  <item cmd="PR or fuzzy match on prototype or vibe-code" action="Guide vibe coding of an early wedge product. Load wedge-definition.md, value-proposition.md, and technical-architecture.md if it exists. Reference the 'vibe-code-wedge' tool from {project-root}/ventureOS/techniques/synthetic-tools.csv. Provide step-by-step prompts for using Claude Code / Cursor / Replit to build the earliest testable version of the wedge product. Generate the core feature specification and prompting guidance.">[PR] Prototype — Vibe code an early wedge product (AI-assisted rapid prototyping)</item>
   <item cmd="VS or fuzzy match on vision-story" action="Create the From/To vision story. Load all solution artifacts. Using the template at {project-root}/ventureOS/templates/vision-story.md, articulate: the world before the solution (pain state), the world after (transformed state), and the venture's role in the shift. Save to {output_folder}/{venture_name}/vision-story.md">[VS] Vision Story — Craft the From/To transformation story</item>
-  <item cmd="RM or fuzzy match on roadmap or product-roadmap" action="Create a product/service roadmap. Load wedge-definition.md, value-proposition.md, and solution-feasibility.md. Using the template at {project-root}/ventureOS/templates/product-roadmap.md, define: Phase 1 (wedge), Phase 2 (expand), Phase 3 (vision). For each phase: features, milestones, success metrics. Save to {output_folder}/{venture_name}/product-roadmap.md">[RM] Product Roadmap — Build wedge-to-vision product roadmap</item>
+  <item cmd="RM or fuzzy match on roadmap or product-roadmap" action="Create a multi-dimensional product roadmap. Load wedge-definition.md, value-proposition.md, solution-feasibility.md, and technical-architecture.md if it exists. Structure the roadmap across three phases (Validate / Automate / Scale) and the following dimensions — for each cell state the specific objective and 1-3 concrete deliverables:
+    - Data &amp; Integrations: what data sources are connected per phase, what connectors are built, how data coverage expands.
+    - Intelligence: what models or analytical capabilities are live per phase, how the intelligence matures (rule-based → ML → autonomous recommendations).
+    - Product &amp; UX: what the user-facing product looks like per phase, key screens or features shipped, how self-service and complexity evolve.
+    - Infrastructure: deployment model, security posture, scalability investments per phase.
+    - Asset Classes / Verticals: which customer segments, use cases, or geographies are targeted per phase — start narrow, expand deliberately.
+    Also include: milestone timeline (Month 0 / Month 6 / Month 12 / Month 24), the scaling hypothesis connecting each phase to the next, and the per-phase success metrics that must be hit before advancing.
+    Save to {output_folder}/{venture_name}/product-roadmap.md and update venture-state.yaml.">[RM] Product Roadmap — Multi-dimensional: Data/Intelligence/UX/Infra/Verticals per phase</item>
   <item cmd="MH or fuzzy match on menu or help">[MH] Redisplay Menu</item>
   <item cmd="CH or fuzzy match on chat">[CH] Chat with Paulo about solution design and wedge strategy</item>
   <item cmd="DA or fuzzy match on exit, leave, goodbye or dismiss agent">[DA] Dismiss Agent</item>

package/agents/venture-ops.md

@@ -67,7 +67,34 @@ These are your operating instructions for this VentureOS session. You are Claude
   <item cmd="MA or fuzzy match on mothership-alignment or asset-jam" workflow="{project-root}/ventureOS/workflows/1-setup-team/mothership-alignment/workflow.yaml">[MA] Mothership Alignment — Asset Jam, sponsor alignment, budget and operational support</item>
   <item cmd="VC or fuzzy match on venture-canvas" action="Guide the user through creating a Venture Canvas using the template at {project-root}/ventureOS/templates/venture-canvas.md. Fill in: reason to exist, challenge statement, initial hypotheses, team composition, timeline. Save to {output_folder}/{venture_name}/venture-canvas.md">[VC] Venture Canvas — Frame the venture reason to exist and starting challenge</item>
   <item cmd="SK or fuzzy match on stakeholder-map" action="Guide the user through creating an AI Stakeholder Map using the template at {project-root}/ventureOS/templates/stakeholder-map.md. Map: who matters, what they care about, what power they have, what relationship to build. Save to {output_folder}/{venture_name}/stakeholder-map.md">[SK] Stakeholder Map — Identify who matters in the venture ecosystem</item>
-  <item cmd="EP or fuzzy match on experiment-plan or operating-plan" action="Guide the user through creating an Operating and Experiment Plan using the template at {project-root}/ventureOS/templates/experiment-plan.md. Save to {output_folder}/{venture_name}/experiment-plan.md">[EP] Experiment Plan — Create the operating and experiment plan for the next phase</item>
+  <item cmd="OP or fuzzy match on operating-plan or ops-plan" action="Build the full venture operating plan. Load product-roadmap.md, gtm-plan.md, monetisation-plan.md, financial-model.md, and venture-state.yaml. Produce a structured operating plan across Validate / Automate / Scale phases. For each phase, cover three dimensions:
+    (1) Product — objective for this phase, key product milestones (what gets built or validated), data/integration milestones, intelligence milestones, infrastructure investments, and the product question this phase must answer.
+    (2) Go-to-Market — GTM objective, primary motion and channels active this phase, pilot or customer targets (number and type), key GTM experiments to run, sales process stage focus, and the commercial question this phase must answer.
+    (3) Business Model — monetization model active this phase (free / pilot / paid tier), unit economics targets (CAC, payback, gross margin), cost structure focus (what the money is spent on), and the financial question this phase must answer.
+    Also include for each phase: timeline (start month → end month), total FTE count, key risks, and the 3 specific criteria that must be true to advance to the next phase.
+    Finish with a 90-day action table: for the current phase, list the top actions across Product, GTM, and Business Model — each with owner, deadline, and success definition.
+    Save to {output_folder}/{venture_name}/operating-plan.md and update venture-state.yaml.">[OP] Operating Plan — Per-phase plan: Product + GTM + Business Model dimensions with 90-day actions</item>
+  <item cmd="TB or fuzzy match on team-building or hiring-plan or headcount" action="Build the phased team building plan. Load venture-state.yaml, operating-plan.md if it exists, and financial-model.md if it exists. Produce:
+    (1) Founding team — current team composition: names (or roles), responsibilities, time commitment (full-time / part-time / advisor), and any critical skill gaps.
+    (2) Per-phase headcount plan — for each phase (Validate / Automate / Scale): total FTE count, new roles added this phase (role title, function: Product / GTM / Ops / Finance), hire timing (which month of the phase), rationale for why this role is needed at this point, and estimated fully-loaded annual cost.
+    (3) Team structure evolution — show how the org structure changes from a 3-person founding team to a scaled team, phase by phase.
+    (4) Hiring priorities — the single most important hire per phase and why, and the hire that would most accelerate the venture if budget allowed.
+    (5) Skill gap analysis — capabilities the current team is missing that are critical for the next phase, and how each gap will be filled (hire / advisor / partner / tool).
+    Save to {output_folder}/{venture_name}/team-building-plan.md and update venture-state.yaml.">[TB] Team Building Plan — Per-phase headcount, hiring sequence, and skill gap analysis</item>
+  <item cmd="IR or fuzzy match on impact-roadmap or impact or sustainability" action="Build the venture impact roadmap. Load venture-state.yaml, product-roadmap.md, financial-model.md, and market-sizing.md. Produce:
+    (1) Impact thesis — in 2-3 sentences, the causal chain from this venture's product to its ultimate societal, environmental, or economic impact. What changes in the world because this venture succeeds?
+    (2) Impact dimensions — identify 3-5 quantifiable impact metrics relevant to the venture's domain (e.g. CO₂ emissions avoided, water saved, energy efficiency gains, jobs created, cost savings unlocked, underserved populations reached). For each: unit of measurement, current baseline, and why it matters.
+    (3) Impact roadmap — for each venture milestone (end of Validate / end of Automate / Scale inflection / long-term vision): projected impact per dimension based on the number of customers, sites, or users served. Show the compounding effect as the venture scales.
+    (4) Parent org / mothership contribution — if applicable, frame the venture's impact in terms meaningful to the parent organization: contribution to ESG targets, strategic objectives, regulatory commitments, or brand positioning.
+    (5) Impact assumptions — label the key assumptions underlying each impact estimate (e.g. average savings per site, adoption rate, baseline emissions per customer). Flag which are sourced vs. estimated.
+    Save to {output_folder}/{venture_name}/impact-roadmap.md and update venture-state.yaml.">[IR] Impact Roadmap — Quantified impact milestones per phase with parent org framing</item>
+  <item cmd="EP or fuzzy match on experiment-plan or next-phase-plan" action="Build the experiment plan for the current phase. Load venture-state.yaml to determine the current phase, and load operating-plan.md and product-roadmap.md if they exist. For the current phase produce:
+    (1) Phase objective — the single most important question this phase must answer (one sentence).
+    (2) Experiment list — the 3-5 experiments to run this phase. For each: hypothesis (if we do X, we expect Y because Z), metric to measure, success threshold (what GO looks like), failure threshold (what STOP looks like), owner, and timeline.
+    (3) 30-60-90 day action plan — specific tasks per function (Product, GTM, Ops) organized by month. Each task: what, who, by when, done-when.
+    (4) Dependencies and blockers — what needs to be true or in place before experiments can start, and how to unblock each.
+    (5) Resource requirements — people, tools, budget needed to run this phase's experiments.
+    Save to {output_folder}/{venture_name}/experiment-plan.md and update venture-state.yaml.">[EP] Experiment Plan — Phase experiment list with 30-60-90 day action plan and blockers</item>
   <item cmd="MH or fuzzy match on menu or help">[MH] Redisplay Menu</item>
   <item cmd="CH or fuzzy match on chat">[CH] Chat with Olivia about team setup or mothership strategy</item>
   <item cmd="DA or fuzzy match on exit, leave, goodbye or dismiss agent">[DA] Dismiss Agent</item>

package/install.js

@@ -16,7 +16,7 @@ import { stdin as input, stdout as output } from 'process';
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { spawnSync } from 'child_process';
+import { spawnSync, spawn } from 'child_process';
 
 const __filename = fileURLToPath(import.meta.url);
 const PACKAGE_ROOT = path.dirname(__filename);
@@ -594,7 +594,7 @@ async function update() {
 
   console.log(`  Updating to VentureOS v${pkg.version}...\n`);
   console.log('  Your work is safe — these are never touched:\n');
-  console.log('    ✓  ventureOS/config.yaml        (your settings)');
+  console.log('    ✓  ventureOS/config.yaml        (your values — comments refreshed)');
   console.log('    ✓  ventureOS/_memory/            (your venture state)');
   console.log('    ✓  _ventures/                    (all your documents)\n');
   console.log(line());
@@ -610,6 +610,17 @@ async function update() {
   console.log('  ✓  techniques/ updated');
   console.log('  ✓  scoring/ updated');
 
+  // Refresh config.yaml comments/template while preserving user values
+  const existingConfig = parseSimpleYaml(fs.readFileSync(configPath, 'utf8'));
+  const refreshedConfig = generateConfig({
+    userName:      existingConfig.user_name      || '',
+    researchDepth: existingConfig.research_depth || 'standard',
+    llm:           existingConfig.llm            || 'claude-code',
+    defaultMode:   existingConfig.default_mode   || 'guided',
+  });
+  fs.writeFileSync(configPath, refreshedConfig, 'utf8');
+  console.log('  ✓  config.yaml comments refreshed  (your values preserved)');
+
   console.log('\n' + line());
   console.log(`  VentureOS is up to date!  (v${pkg.version})`);
   console.log(line() + '\n');
@@ -844,6 +855,47 @@ async function callLLM(provider, apiKey, model, system, messages) {
   throw new Error(`Unknown provider: ${provider}`);
 }
 
+async function callViaCLI(cliCmd, system, messages) {
+  // Build full context: system + conversation history + latest user message.
+  // Sent via stdin to avoid ARG_MAX limits and CLI option-parsing issues
+  // (e.g. prompts that start with "---" being misread as flags).
+  let prompt = system + '\n\n';
+
+  for (const msg of messages.slice(0, -1)) {
+    const role = msg.role === 'user' ? 'Human' : 'Assistant';
+    prompt += `${role}: ${msg.content}\n\n`;
+  }
+
+  const lastMsg = messages[messages.length - 1];
+  prompt += `Human: ${lastMsg.content}`;
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn(cliCmd, ['--print', '--dangerously-skip-permissions'], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', chunk => { stdout += chunk; });
+    proc.stderr.on('data', chunk => { stderr += chunk; });
+
+    proc.on('close', code => {
+      if (code !== 0) {
+        reject(new Error(stderr.trim() || `${cliCmd} CLI exited with code ${code}`));
+      } else {
+        resolve(stdout.trim());
+      }
+    });
+
+    proc.on('error', reject);
+
+    proc.stdin.write(prompt, 'utf8');
+    proc.stdin.end();
+  });
+}
+
+
 async function callAnthropic(apiKey, model, system, messages) {
   const res = await fetch('https://api.anthropic.com/v1/messages', {
     method: 'POST',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ventureos",
-  "version": "1.1.5",
+  "version": "1.1.7",
   "description": "VentureOS — AI-powered venture building framework. From raw idea to investor-ready pitch in 12 structured weeks.",
   "type": "module",
   "bin": {