@ai-matrx/agents 0.10.6 → 0.11.0

package/dist/content-transfer/react/index.cjs

@@ -0,0 +1,1564 @@
+"use client";
+"use strict";
+"use client";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// content-transfer/react/index.tsx
+var react_exports = {};
+__export(react_exports, {
+  MatrxContentTransferProvider: () => MatrxContentTransferProvider
+});
+module.exports = __toCommonJS(react_exports);
+var React = __toESM(require("react"), 1);
+var import_content_transfer2 = require("@ai-matrx/design-system/content-transfer");
+
+// content-transfer/index.ts
+var import_content_transfer = require("@ai-matrx/kit/content-transfer");
+
+// mandates/keys.generated.ts
+var MANDATE_KEYS = {
+  agent_apps__auto_create: "agent_apps.auto_create",
+  agent_apps__auto_create_lightning: "agent_apps.auto_create_lightning",
+  agent_apps__metadata: "agent_apps.metadata",
+  agent_apps__prompt_app_dev: "agent_apps.prompt_app_dev",
+  agent_factory__structure_builder: "agent_factory.structure_builder",
+  alchemy__prepare_content: "alchemy.prepare_content",
+  ambient__page_guidance: "ambient.page_guidance",
+  ambient__spoken_summary: "ambient.spoken_summary",
+  chat__cx_default: "chat.cx_default",
+  chat__default_new_chat: "chat.default_new_chat",
+  chat__quick_audio_plan: "chat.quick_audio_plan",
+  chat__quick_fair_news: "chat.quick_fair_news",
+  chat__quick_flashcards: "chat.quick_flashcards",
+  chat__quick_image: "chat.quick_image",
+  chat__quick_org_chart: "chat.quick_org_chart",
+  chat__quick_research: "chat.quick_research",
+  chat__quick_showcase: "chat.quick_showcase",
+  chat__quick_writing_partner: "chat.quick_writing_partner",
+  chat__response_mode_brainstorm: "chat.response_mode_brainstorm",
+  chat__response_mode_data: "chat.response_mode_data",
+  chat__response_mode_research: "chat.response_mode_research",
+  chat__response_mode_video: "chat.response_mode_video",
+  code_editor__code_edit: "code_editor.code_edit",
+  code_editor__dynamic_context_edit: "code_editor.dynamic_context_edit",
+  code_editor__prompt_app_ui_edit: "code_editor.prompt_app_ui_edit",
+  coding_session__managed_translation_reference: "coding_session.managed_translation_reference",
+  commerce_intake__assess_value: "commerce_intake.assess_value",
+  commerce_intake__extract_vision: "commerce_intake.extract_vision",
+  commerce_intake__grading: "commerce_intake.grading",
+  commerce_intake__instant_analysis: "commerce_intake.instant_analysis",
+  commerce_intake__refute_no_value: "commerce_intake.refute_no_value",
+  commerce_intake__research_product: "commerce_intake.research_product",
+  commerce_intake__segment_photos: "commerce_intake.segment_photos",
+  commerce_intake__verify_enrichment: "commerce_intake.verify_enrichment",
+  content_ir__component_artisan: "content_ir.component_artisan",
+  content_ir__kind_architect: "content_ir.kind_architect",
+  content_ir__kind_component_builder: "content_ir.kind_component_builder",
+  content_ir__kind_creator: "content_ir.kind_creator",
+  content_plan__brief_writer: "content_plan.brief_writer",
+  content_plan__entity_attacher: "content_plan.entity_attacher",
+  content_plan__entity_curator: "content_plan.entity_curator",
+  content_plan__family_namer: "content_plan.family_namer",
+  content_plan__keyword_strategist: "content_plan.keyword_strategist",
+  content_plan__p3_family: "content_plan.p3_family",
+  content_plan__p4_write: "content_plan.p4_write",
+  content_plan__p5_review: "content_plan.p5_review",
+  content_plan__p6_build: "content_plan.p6_build",
+  content_plan__p6_build__about: "content_plan.p6_build.about",
+  content_plan__p6_build__blog: "content_plan.p6_build.blog",
+  content_plan__p6_build__comparison: "content_plan.p6_build.comparison",
+  content_plan__p6_build__contact: "content_plan.p6_build.contact",
+  content_plan__p6_build__faq: "content_plan.p6_build.faq",
+  content_plan__p6_build__guide: "content_plan.p6_build.guide",
+  content_plan__p6_build__home: "content_plan.p6_build.home",
+  content_plan__p6_build__index: "content_plan.p6_build.index",
+  content_plan__p6_build__location: "content_plan.p6_build.location",
+  content_plan__p6_build__pillar: "content_plan.p6_build.pillar",
+  content_plan__p6_build__pricing: "content_plan.p6_build.pricing",
+  content_plan__p6_build__service: "content_plan.p6_build.service",
+  content_plan__plan_reviewer: "content_plan.plan_reviewer",
+  content_plan__route_picker: "content_plan.route_picker",
+  content_plan__shape_planner: "content_plan.shape_planner",
+  conversation__action_auditor: "conversation.action_auditor",
+  conversation__decision_ledger: "conversation.decision_ledger",
+  conversation__drift_auditor: "conversation.drift_auditor",
+  conversation__outcome_summarizer: "conversation.outcome_summarizer",
+  conversation__vision_extractor: "conversation.vision_extractor",
+  conversation__vision_interviewer: "conversation.vision_interviewer",
+  crm__journalist_beat_analyst: "crm.journalist_beat_analyst",
+  crm__media_list_ranker: "crm.media_list_ranker",
+  crm__outreach_draft_reviewer: "crm.outreach_draft_reviewer",
+  crm__outreach_personalization_coach: "crm.outreach_personalization_coach",
+  crm__outreach_personalization_writer: "crm.outreach_personalization_writer",
+  crm__outreach_pitch_writer: "crm.outreach_pitch_writer",
+  crm__outreach_recipient_shortlister: "crm.outreach_recipient_shortlister",
+  crm__outreach_reply_drafter: "crm.outreach_reply_drafter",
+  crm__party_kind_judge: "crm.party_kind_judge",
+  crm__save_contact: "crm.save_contact",
+  data__page_guidance: "data.page_guidance",
+  dictionary__workspace_guide: "dictionary.workspace_guide",
+  education__admin_guidance: "education.admin_guidance",
+  education__analytics_narrate: "education.analytics_narrate",
+  education__audio_study_guidance: "education.audio_study_guidance",
+  education__card_image_generator: "education.card_image_generator",
+  education__card_image_prompt_writer: "education.card_image_prompt_writer",
+  education__card_image_qc_judge: "education.card_image_qc_judge",
+  education__card_image_web_source: "education.card_image_web_source",
+  education__classes_guidance: "education.classes_guidance",
+  education__creator_guidance: "education.creator_guidance",
+  education__data_guidance: "education.data_guidance",
+  education__exam_prep_guidance: "education.exam_prep_guidance",
+  education__family_guidance: "education.family_guidance",
+  education__fastfire_guidance: "education.fastfire_guidance",
+  education__features_guidance: "education.features_guidance",
+  education__flashcards_guidance: "education.flashcards_guidance",
+  education__game_guidance: "education.game_guidance",
+  education__grade_handwritten: "education.grade_handwritten",
+  education__grade_work_guidance: "education.grade_work_guidance",
+  education__kit_title: "education.kit_title",
+  education__learn_guidance: "education.learn_guidance",
+  education__levels_guidance: "education.levels_guidance",
+  education__library_guidance: "education.library_guidance",
+  education__media_guidance: "education.media_guidance",
+  education__memory_generate: "education.memory_generate",
+  education__memory_guidance: "education.memory_guidance",
+  education__memory_hint: "education.memory_hint",
+  education__mind_maps_guidance: "education.mind_maps_guidance",
+  education__mindmap_generate: "education.mindmap_generate",
+  education__notes_generate: "education.notes_generate",
+  education__notes_guidance: "education.notes_guidance",
+  education__offline_guidance: "education.offline_guidance",
+  education__page_guidance: "education.page_guidance",
+  education__plan_generate: "education.plan_generate",
+  education__planner_guidance: "education.planner_guidance",
+  education__practice_oral_guidance: "education.practice_oral_guidance",
+  education__practice_tests_guidance: "education.practice_tests_guidance",
+  education__progress_guidance: "education.progress_guidance",
+  education__quiz_deepen_item: "education.quiz_deepen_item",
+  education__quiz_generate: "education.quiz_generate",
+  education__quiz_generate_from_source: "education.quiz_generate_from_source",
+  education__quizzes_guidance: "education.quizzes_guidance",
+  education__spoken_practice_design: "education.spoken_practice_design",
+  education__spoken_practice_design_language: "education.spoken_practice_design_language",
+  education__spoken_practice_grade: "education.spoken_practice_grade",
+  education__spoken_practice_grade_pronunciation: "education.spoken_practice_grade_pronunciation",
+  education__spoken_practice_review: "education.spoken_practice_review",
+  education__start_guidance: "education.start_guidance",
+  education__study_aids_guidance: "education.study_aids_guidance",
+  education__study_pack_flashcards: "education.study_pack_flashcards",
+  education__study_pack_lessons: "education.study_pack_lessons",
+  education__study_pack_notes: "education.study_pack_notes",
+  education__study_pack_quiz: "education.study_pack_quiz",
+  education__study_pack_v2_flashcards: "education.study_pack_v2_flashcards",
+  education__study_pack_v2_lessons: "education.study_pack_v2_lessons",
+  education__study_pack_v2_notes: "education.study_pack_v2_notes",
+  education__study_pack_v2_quiz: "education.study_pack_v2_quiz",
+  education__subjects_guidance: "education.subjects_guidance",
+  education__summaries_guidance: "education.summaries_guidance",
+  education__summarize: "education.summarize",
+  education__tutor_guidance: "education.tutor_guidance",
+  education__tutor_message: "education.tutor_message",
+  education__voice_tutor: "education.voice_tutor",
+  extend__browser_chat: "extend.browser_chat",
+  extend__pattern_from_data: "extend.pattern_from_data",
+  extend__structured_extractor: "extend.structured_extractor",
+  flashcards__enrich_card: "flashcards.enrich_card",
+  flashcards__expand_card: "flashcards.expand_card",
+  flashcards__generate_cards: "flashcards.generate_cards",
+  flashcards__generate_from_source: "flashcards.generate_from_source",
+  flashcards__grade_spoken: "flashcards.grade_spoken",
+  flashcards__grade_typed_answer: "flashcards.grade_typed_answer",
+  flashcards__help_live: "flashcards.help_live",
+  flashcards__helper_tts: "flashcards.helper_tts",
+  flashcards__make_quiz_items: "flashcards.make_quiz_items",
+  flashcards__micro_coach: "flashcards.micro_coach",
+  flashcards__review_batch: "flashcards.review_batch",
+  flashcards__spoken_front_tts: "flashcards.spoken_front_tts",
+  flashcards__verify_against_source: "flashcards.verify_against_source",
+  foundry__planner: "foundry.planner",
+  growth_loop__quality_analyze: "growth_loop.quality_analyze",
+  growth_loop__quality_brief: "growth_loop.quality_brief",
+  growth_loop__quality_crawl: "growth_loop.quality_crawl",
+  growth_loop__quality_fill: "growth_loop.quality_fill",
+  growth_loop__quality_measure: "growth_loop.quality_measure",
+  growth_loop__quality_plan: "growth_loop.quality_plan",
+  growth_loop__quality_publish: "growth_loop.quality_publish",
+  growth_loop__quality_realize: "growth_loop.quality_realize",
+  growth_loop__quality_research: "growth_loop.quality_research",
+  growth_loop__quality_serve: "growth_loop.quality_serve",
+  growth_loop__quality_suggest: "growth_loop.quality_suggest",
+  growth_loop__quality_writeback: "growth_loop.quality_writeback",
+  growth_loop__supervisor: "growth_loop.supervisor",
+  hindsight__crystallizer: "hindsight.crystallizer",
+  hindsight__replay_judge: "hindsight.replay_judge",
+  hindsight__reviewer: "hindsight.reviewer",
+  human_decisions__fallback_decider: "human_decisions.fallback_decider",
+  iteration__architect: "iteration.architect",
+  iteration__diagnostic: "iteration.diagnostic",
+  iteration__root_cause: "iteration.root_cause",
+  iteration__thinking_display: "iteration.thinking_display",
+  kg__cluster_namer: "kg.cluster_namer",
+  kg__ner_extractor: "kg.ner_extractor",
+  knowledge__document_verifier: "knowledge.document_verifier",
+  knowledge__qa_generator: "knowledge.qa_generator",
+  knowledge__section_summarizer: "knowledge.section_summarizer",
+  local__cloud_chat: "local.cloud_chat",
+  marketing__endowment_analysis: "marketing.endowment_analysis",
+  marketing__endowment_portfolio: "marketing.endowment_portfolio",
+  marketing__image_prompt: "marketing.image_prompt",
+  marketing__page_image: "marketing.page_image",
+  marketing__page_image_all_in_one: "marketing.page_image_all_in_one",
+  marketing__video_metadata: "marketing.video_metadata",
+  masterwork__approach_selector: "masterwork.approach_selector",
+  masterwork__audition_judge: "masterwork.audition_judge",
+  masterwork__bad_draft: "masterwork.bad_draft",
+  masterwork__checkup_auditor: "masterwork.checkup_auditor",
+  masterwork__coherence_partner: "masterwork.coherence_partner",
+  masterwork__conductor: "masterwork.conductor",
+  masterwork__corpus_cleaner: "masterwork.corpus_cleaner",
+  masterwork__corpus_synthesizer: "masterwork.corpus_synthesizer",
+  masterwork__draft_triage: "masterwork.draft_triage",
+  masterwork__exception_hunter: "masterwork.exception_hunter",
+  masterwork__exemplar_distiller: "masterwork.exemplar_distiller",
+  masterwork__intake_designer: "masterwork.intake_designer",
+  masterwork__monologue_distiller: "masterwork.monologue_distiller",
+  masterwork__outcome_judge: "masterwork.outcome_judge",
+  masterwork__relationship_auditor: "masterwork.relationship_auditor",
+  masterwork__rule_improver: "masterwork.rule_improver",
+  masterwork__rulebook_auditor: "masterwork.rulebook_auditor",
+  masterwork__scout: "masterwork.scout",
+  masterwork__source_distiller: "masterwork.source_distiller",
+  masterwork__template__chief_edit: "masterwork.template.chief_edit",
+  masterwork__template__chief_generate: "masterwork.template.chief_generate",
+  masterwork__template__editor: "masterwork.template.editor",
+  masterwork__template__maker: "masterwork.template.maker",
+  masterwork__timeline_distiller: "masterwork.timeline_distiller",
+  masterwork__timeline_segmenter: "masterwork.timeline_segmenter",
+  masterwork__transcript_distiller: "masterwork.transcript_distiller",
+  masterwork__transcript_shortlister: "masterwork.transcript_shortlister",
+  masterwork__understudy: "masterwork.understudy",
+  media__youtube_analyzer: "media.youtube_analyzer",
+  meet__live_intelligence: "meet.live_intelligence",
+  meet__live_notes: "meet.live_notes",
+  meet__wrap_up: "meet.wrap_up",
+  messaging__action_item_extraction: "messaging.action_item_extraction",
+  messaging__conversation_catch_up: "messaging.conversation_catch_up",
+  messaging__conversation_summary: "messaging.conversation_summary",
+  messaging__reply_drafting: "messaging.reply_drafting",
+  ner__deep_chunk_extractor: "ner.deep_chunk_extractor",
+  ner__document_orienter: "ner.document_orienter",
+  ner__entity_canonicalizer: "ner.entity_canonicalizer",
+  ner__finisher: "ner.finisher",
+  ner__item_proposer: "ner.item_proposer",
+  ner__magic_moment_detector: "ner.magic_moment_detector",
+  ner__scope_proposer: "ner.scope_proposer",
+  ner__scope_slot_filler: "ner.scope_slot_filler",
+  ner__suggestion_reviewer: "ner.suggestion_reviewer",
+  ner__sweep_scope_discoverer: "ner.sweep_scope_discoverer",
+  ner__sweep_scope_reference_finder: "ner.sweep_scope_reference_finder",
+  ner__sweep_value_miner: "ner.sweep_value_miner",
+  notes__organizer: "notes.organizer",
+  notes__page_guidance: "notes.page_guidance",
+  observability__tool_trace_pattern_detection: "observability.tool_trace_pattern_detection",
+  observability__tool_trace_triage: "observability.tool_trace_triage",
+  orchestras__role_describer: "orchestras.role_describer",
+  pdf__content_cleaner: "pdf.content_cleaner",
+  podcast__audience_adapter: "podcast.audience_adapter",
+  podcast__audio_dialogue: "podcast.audio_dialogue",
+  podcast__audio_english: "podcast.audio_english",
+  podcast__audio_persian: "podcast.audio_persian",
+  podcast__chapter_marker: "podcast.chapter_marker",
+  podcast__content_extractor: "podcast.content_extractor",
+  podcast__deep_research: "podcast.deep_research",
+  podcast__image_v1: "podcast.image_v1",
+  podcast__image_v2: "podcast.image_v2",
+  podcast__image_v3: "podcast.image_v3",
+  podcast__image_v4: "podcast.image_v4",
+  podcast__image_v5: "podcast.image_v5",
+  podcast__image_v6_feature: "podcast.image_v6_feature",
+  podcast__image_v6_feature_prompt: "podcast.image_v6_feature_prompt",
+  podcast__live_rewrite: "podcast.live_rewrite",
+  podcast__metadata: "podcast.metadata",
+  podcast__multihost_script: "podcast.multihost_script",
+  podcast__post_prep_expansion: "podcast.post_prep_expansion",
+  podcast__post_prep_fact_checking: "podcast.post_prep_fact_checking",
+  podcast__post_prep_summarization: "podcast.post_prep_summarization",
+  podcast__post_prep_translation: "podcast.post_prep_translation",
+  podcast__race_frontier: "podcast.race_frontier",
+  podcast__relevance_gate: "podcast.relevance_gate",
+  podcast__roundtable_script: "podcast.roundtable_script",
+  podcast__script_educational: "podcast.script_educational",
+  podcast__script_news: "podcast.script_news",
+  podcast__script_persian: "podcast.script_persian",
+  podcast__solo_script: "podcast.solo_script",
+  podcast__title_optimizer: "podcast.title_optimizer",
+  podcast__video_v1: "podcast.video_v1",
+  podcast__video_v2: "podcast.video_v2",
+  podcast_client__blog_writer: "podcast_client.blog_writer",
+  podcast_client__show_notes: "podcast_client.show_notes",
+  podcast_client__topic_ideas: "podcast_client.topic_ideas",
+  podcast_client__web_content_extractor: "podcast_client.web_content_extractor",
+  podcast_client__youtube_research: "podcast_client.youtube_research",
+  product_capture__instant_analysis: "product_capture.instant_analysis",
+  projects__creation_guide: "projects.creation_guide",
+  proof_runs__judge: "proof_runs.judge",
+  purpose__writer: "purpose.writer",
+  rag__chunk_contextualizer: "rag.chunk_contextualizer",
+  rag__hyde_generator: "rag.hyde_generator",
+  rag__pdf_page_cleaner: "rag.pdf_page_cleaner",
+  rag__query_expander: "rag.query_expander",
+  research__auto_tagger: "research.auto_tagger",
+  research__condenser_1: "research.condenser_1",
+  research__condenser_2: "research.condenser_2",
+  research__coverage_audit: "research.coverage_audit",
+  research__cross_cutting_tags: "research.cross_cutting_tags",
+  research__document_assembly: "research.document_assembly",
+  research__keyword_synthesis: "research.keyword_synthesis",
+  research__report: "research.report",
+  research__report_updater: "research.report_updater",
+  research__source_authority: "research.source_authority",
+  research__structured_page_summary: "research.structured_page_summary",
+  research__suggest_setup: "research.suggest_setup",
+  research__tag_consolidation: "research.tag_consolidation",
+  research_client__output_blog: "research_client.output_blog",
+  research_client__output_brand_profile: "research_client.output_brand_profile",
+  research_client__output_competitive_landscape: "research_client.output_competitive_landscape",
+  research_client__output_gap_analysis: "research_client.output_gap_analysis",
+  research_client__output_literature_review: "research_client.output_literature_review",
+  research_client__output_reputation_business: "research_client.output_reputation_business",
+  research_client__output_reputation_personal: "research_client.output_reputation_personal",
+  research_client__output_seo: "research_client.output_seo",
+  research_client__output_slides: "research_client.output_slides",
+  scraper__fact_check: "scraper.fact_check",
+  scraper__keyword_analysis: "scraper.keyword_analysis",
+  seo__ai_visibility_decision_analyst: "seo.ai_visibility_decision_analyst",
+  seo__backlink_context_assessor: "seo.backlink_context_assessor",
+  seo__backlink_work_planner: "seo.backlink_work_planner",
+  seo__business_model_verdict: "seo.business_model_verdict",
+  seo__competitor_classifier: "seo.competitor_classifier",
+  seo__competitor_opportunity_autopsy: "seo.competitor_opportunity_autopsy",
+  seo__competitor_page_autopsy: "seo.competitor_page_autopsy",
+  seo__coverage_analyst: "seo.coverage_analyst",
+  seo__digital_pr_reputation_adjudicator: "seo.digital_pr_reputation_adjudicator",
+  seo__evidence_workbench: "seo.evidence_workbench",
+  seo__finding_fixer: "seo.finding_fixer",
+  seo__guidelines_drafter: "seo.guidelines_drafter",
+  seo__ideal_customer_profile: "seo.ideal_customer_profile",
+  seo__keyword_classifier: "seo.keyword_classifier",
+  seo__keyword_expander: "seo.keyword_expander",
+  seo__keyword_researcher: "seo.keyword_researcher",
+  seo__keyword_serp_intent_analyst: "seo.keyword_serp_intent_analyst",
+  seo__landscape_brief: "seo.landscape_brief",
+  seo__money_map: "seo.money_map",
+  seo__offering_extraction: "seo.offering_extraction",
+  seo__offering_valuation: "seo.offering_valuation",
+  seo__page_analyzer: "seo.page_analyzer",
+  seo__page_keyword_mapper: "seo.page_keyword_mapper",
+  seo__press_source_request_responder: "seo.press_source_request_responder",
+  seo__press_story_analyst: "seo.press_story_analyst",
+  seo__session_rule_writer: "seo.session_rule_writer",
+  seo__session_stamp_proposer: "seo.session_stamp_proposer",
+  seo__site_intake: "seo.site_intake",
+  seo__site_link_authority_router: "seo.site_link_authority_router",
+  seo__site_strategist: "seo.site_strategist",
+  seo__starter_pack_proposer: "seo.starter_pack_proposer",
+  seo__topic_assigner: "seo.topic_assigner",
+  sms__owner_beta: "sms.owner_beta",
+  surfaces_client__binding_mapper: "surfaces_client.binding_mapper",
+  tasks__triage: "tasks.triage",
+  tool_viz__component_generator: "tool_viz.component_generator",
+  tools__summarize_content: "tools.summarize_content",
+  transcript_studio__document_edit: "transcript_studio.document_edit",
+  transcript_studio__scribe_live: "transcript_studio.scribe_live",
+  vision_interview__adversary: "vision_interview.adversary",
+  vision_interview__amplifier: "vision_interview.amplifier",
+  vision_interview__answer_tracker: "vision_interview.answer_tracker",
+  vision_interview__archaeologist: "vision_interview.archaeologist",
+  vision_interview__architect: "vision_interview.architect",
+  vision_interview__cartographer: "vision_interview.cartographer",
+  vision_interview__requirements_author: "vision_interview.requirements_author",
+  vision_interview__scribe: "vision_interview.scribe",
+  vision_interview__sounding_board: "vision_interview.sounding_board",
+  vision_interview__transcript_cleaner: "vision_interview.transcript_cleaner",
+  vision_interview__vision_author: "vision_interview.vision_author",
+  voice__communicator: "voice.communicator",
+  voice__intro: "voice.intro",
+  voice__owner_beta: "voice.owner_beta",
+  war_room__master: "war_room.master",
+  war_room__room: "war_room.room",
+  war_room__thread: "war_room.thread",
+  web__endpoint_family_judge: "web.endpoint_family_judge",
+  workflow__complex_research__keyword_synthesis: "workflow.complex_research.keyword_synthesis",
+  workflow__complex_research__page_summary: "workflow.complex_research.page_summary",
+  workflow__complex_research__report: "workflow.complex_research.report",
+  workflow__conductor: "workflow.conductor",
+  workflow__deep_research__keyword_synthesis: "workflow.deep_research.keyword_synthesis",
+  workflow__extract_namer: "workflow.extract_namer",
+  workflow__plan_design: "workflow.plan_design",
+  workflow__plan_input_kind_authoring: "workflow.plan_input_kind_authoring",
+  workflow__plan_node_type_recommender: "workflow.plan_node_type_recommender",
+  workflow__plan_notes_writer: "workflow.plan_notes_writer",
+  workflow__plan_output_kind_authoring: "workflow.plan_output_kind_authoring",
+  workflow__recovery_advisor: "workflow.recovery_advisor",
+  workflow__run_assist_suggester: "workflow.run_assist_suggester",
+  workflow__step_intelligence: "workflow.step_intelligence",
+  workflow__steward: "workflow.steward",
+  workflow__steward__agent_run: "workflow.steward.agent_run",
+  workflow__steward__data: "workflow.steward.data",
+  workflow__steward__decision: "workflow.steward.decision",
+  workflow__steward__user_input: "workflow.steward.user_input"
+};
+var ALL_MANDATE_KEYS = Object.values(MANDATE_KEYS);
+
+// mandates/index.ts
+var KEY_SET = new Set(ALL_MANDATE_KEYS);
+
+// matrx/transport.ts
+var MatrxApiError = class extends Error {
+  name = "MatrxApiError";
+  /** HTTP status of the failed response. */
+  status;
+  /** Machine code from the server body (`code`, or `detail.code`), when present. */
+  code;
+  /** The parsed server error body, verbatim (undefined when unparsable). */
+  serverDetail;
+  /** The request path the failure came from (server-relative). */
+  path;
+  constructor(args) {
+    super(
+      args.message ?? extractMatrxErrorMessage(args.serverDetail) ?? `HTTP ${args.status}`
+    );
+    this.status = args.status;
+    this.path = args.path;
+    this.serverDetail = args.serverDetail;
+    this.code = extractMatrxErrorCode(args.serverDetail);
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonBlankString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function extractMatrxErrorMessage(serverDetail) {
+  if (!isRecord(serverDetail)) return void 0;
+  const userMessage = nonBlankString(serverDetail.user_message);
+  if (userMessage) return userMessage;
+  const message = nonBlankString(serverDetail.message);
+  if (message) return message;
+  if (Array.isArray(serverDetail.details)) {
+    const messages = serverDetail.details.map((entry) => {
+      if (!isRecord(entry)) return void 0;
+      const detailMessage = nonBlankString(entry.message);
+      if (!detailMessage) return void 0;
+      const field = nonBlankString(entry.field);
+      return field ? `${field}: ${detailMessage}` : detailMessage;
+    }).filter((m) => typeof m === "string");
+    if (messages.length > 0) return messages.join("; ");
+  }
+  const detail = serverDetail.detail;
+  if (isRecord(detail)) {
+    const detailMessage = nonBlankString(detail.message) ?? nonBlankString(detail.user_message);
+    if (detailMessage) return detailMessage;
+  }
+  if (typeof detail === "string" && detail.trim()) return detail;
+  if (Array.isArray(detail)) {
+    const messages = detail.map(
+      (entry) => isRecord(entry) ? nonBlankString(entry.msg) : void 0
+    ).filter((m) => typeof m === "string");
+    if (messages.length > 0) return messages.join("; ");
+  }
+  return void 0;
+}
+function extractMatrxErrorCode(serverDetail) {
+  if (!isRecord(serverDetail)) return null;
+  const topLevel = nonBlankString(serverDetail.code);
+  if (topLevel) return topLevel;
+  const detail = serverDetail.detail;
+  if (isRecord(detail)) {
+    const nested = nonBlankString(detail.code);
+    if (nested) return nested;
+  }
+  return null;
+}
+
+// matrx/conversation.ts
+function mintMatrxConversationId() {
+  return crypto.randomUUID();
+}
+function newStoredConversationStart(conversationId) {
+  return {
+    conversation_id: conversationId ?? mintMatrxConversationId(),
+    is_new: true,
+    store: true
+  };
+}
+
+// stream/ndjson.ts
+var DEFAULT_MATRX_NDJSON_READ_AHEAD = 64;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeMatrxStreamEnvelope(value) {
+  if (!isRecord2(value)) return null;
+  if (typeof value.event === "string") {
+    const streamSeq = typeof value.stream_seq === "number" && Number.isFinite(value.stream_seq) ? value.stream_seq : void 0;
+    const streamId = typeof value.stream_id === "string" ? value.stream_id : void 0;
+    return {
+      event: value.event,
+      data: value.data,
+      ...streamId === void 0 ? {} : { stream_id: streamId },
+      ...streamSeq === void 0 ? {} : { stream_seq: streamSeq }
+    };
+  }
+  if (value.e === "c" && typeof value.t === "string") {
+    const streamId = typeof value.stream_id === "string" ? value.stream_id : void 0;
+    const streamSeq = typeof value.stream_seq === "number" && Number.isFinite(value.stream_seq) ? value.stream_seq : void 0;
+    return {
+      event: "chunk",
+      data: { text: value.t },
+      ...streamId === void 0 ? {} : { stream_id: streamId },
+      ...streamSeq === void 0 ? {} : { stream_seq: streamSeq }
+    };
+  }
+  if (value.e === "r" && typeof value.t === "string") {
+    const streamId = typeof value.stream_id === "string" ? value.stream_id : void 0;
+    const streamSeq = typeof value.stream_seq === "number" && Number.isFinite(value.stream_seq) ? value.stream_seq : void 0;
+    return {
+      event: "reasoning_chunk",
+      data: { text: value.t },
+      ...streamId === void 0 ? {} : { stream_id: streamId },
+      ...streamSeq === void 0 ? {} : { stream_seq: streamSeq }
+    };
+  }
+  return null;
+}
+function createMatrxNdjsonFramer(options = {}) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let lineNumber = 0;
+  let finished = false;
+  const assertOpen = () => {
+    if (finished) throw new Error("Matrx NDJSON framer is already finished");
+  };
+  const parseLine = (line, atCompletion) => {
+    const currentLineNumber = ++lineNumber;
+    const trimmed = line.trim();
+    if (!trimmed) return null;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch (error) {
+      options.onMalformedLine?.({
+        line: trimmed,
+        error,
+        lineNumber: currentLineNumber,
+        atCompletion
+      });
+      return null;
+    }
+    const envelope = normalizeMatrxStreamEnvelope(parsed);
+    if (!envelope) {
+      options.onUnknownEnvelope?.(parsed);
+      return null;
+    }
+    options.onValidEnvelope?.({
+      raw: parsed,
+      envelope,
+      line: trimmed,
+      lineNumber: currentLineNumber,
+      atCompletion
+    });
+    return envelope;
+  };
+  const pushDecodedText = (fragment) => {
+    buffer += fragment;
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    const envelopes = [];
+    for (const line of lines) {
+      const envelope = parseLine(line, false);
+      if (envelope) envelopes.push(envelope);
+    }
+    return envelopes;
+  };
+  return {
+    pushText(fragment) {
+      assertOpen();
+      return pushDecodedText(decoder.decode() + fragment);
+    },
+    pushBytes(fragment) {
+      assertOpen();
+      return pushDecodedText(decoder.decode(fragment, { stream: true }));
+    },
+    finish() {
+      assertOpen();
+      finished = true;
+      const envelopes = pushDecodedText(decoder.decode());
+      if (buffer.length > 0) {
+        const envelope = parseLine(buffer, true);
+        buffer = "";
+        if (envelope) envelopes.push(envelope);
+      }
+      return envelopes;
+    }
+  };
+}
+function readAheadLimit(value) {
+  const limit = value ?? DEFAULT_MATRX_NDJSON_READ_AHEAD;
+  if (!Number.isSafeInteger(limit) || limit < 1) {
+    throw new RangeError("maxReadAhead must be a positive safe integer");
+  }
+  return limit;
+}
+async function* readMatrxNdjsonStream(body, options = {}) {
+  const maxReadAhead = readAheadLimit(options.maxReadAhead);
+  const queue = [];
+  let queuedEventCount = 0;
+  let wakeConsumer = null;
+  let wakeProducer = null;
+  let readerFinished = false;
+  let consumerClosed = false;
+  const wakeWaitingConsumer = () => {
+    const wake = wakeConsumer;
+    wakeConsumer = null;
+    wake?.();
+  };
+  const wakeWaitingProducer = () => {
+    const wake = wakeProducer;
+    wakeProducer = null;
+    wake?.();
+  };
+  const enqueueTerminal = (item) => {
+    if (consumerClosed) return;
+    queue.push(item);
+    wakeWaitingConsumer();
+  };
+  const enqueueEvent = async (value) => {
+    while (queuedEventCount >= maxReadAhead && !consumerClosed && !options.signal?.aborted) {
+      await new Promise((resolve2) => {
+        wakeProducer = resolve2;
+      });
+    }
+    if (consumerClosed || options.signal?.aborted) return false;
+    queue.push({ kind: "event", value });
+    queuedEventCount += 1;
+    wakeWaitingConsumer();
+    return true;
+  };
+  const waitForReadCapacity = async () => {
+    while (queuedEventCount >= maxReadAhead && !consumerClosed && !options.signal?.aborted) {
+      await new Promise((resolve2) => {
+        wakeProducer = resolve2;
+      });
+    }
+    return !consumerClosed && !options.signal?.aborted;
+  };
+  const reader = body.getReader();
+  const framer = createMatrxNdjsonFramer(options);
+  const onAbort = () => {
+    wakeWaitingProducer();
+    wakeWaitingConsumer();
+    void reader.cancel(options.signal?.reason).catch(() => void 0);
+  };
+  options.signal?.addEventListener("abort", onAbort, { once: true });
+  if (options.signal?.aborted) onAbort();
+  const readerPromise = (async () => {
+    try {
+      while (!options.signal?.aborted && !consumerClosed) {
+        if (!await waitForReadCapacity()) return;
+        const { value, done } = await reader.read();
+        if (done) break;
+        for (const envelope of framer.pushBytes(value)) {
+          if (!await enqueueEvent(envelope)) return;
+        }
+      }
+      if (!options.signal?.aborted && !consumerClosed) {
+        for (const envelope of framer.finish()) {
+          if (!await enqueueEvent(envelope)) return;
+        }
+      }
+    } catch (error) {
+      const aborted = options.signal?.aborted || consumerClosed || error instanceof Error && error.name === "AbortError";
+      if (!aborted) enqueueTerminal({ kind: "error", error });
+    } finally {
+      readerFinished = true;
+      reader.releaseLock();
+      enqueueTerminal({ kind: "done" });
+    }
+  })();
+  try {
+    while (true) {
+      if (queue.length === 0) {
+        if (options.signal?.aborted || readerFinished) return;
+        await new Promise((resolve2) => {
+          wakeConsumer = resolve2;
+        });
+      }
+      const item = queue.shift();
+      if (item?.kind === "event") queuedEventCount -= 1;
+      wakeWaitingProducer();
+      if (!item || item.kind === "done") return;
+      if (item.kind === "error") throw item.error;
+      yield item.value;
+    }
+  } finally {
+    consumerClosed = true;
+    wakeWaitingProducer();
+    wakeWaitingConsumer();
+    options.signal?.removeEventListener("abort", onAbort);
+    if (!readerFinished) {
+      await reader.cancel().catch(() => void 0);
+    }
+    await readerPromise;
+  }
+}
+
+// matrx/internal.ts
+function encodePathSegment(value) {
+  return encodeURIComponent(value);
+}
+function buildQuery(params) {
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0) continue;
+    if (Array.isArray(value)) {
+      for (const entry of value) search.append(key, entry);
+    } else {
+      search.append(key, String(value));
+    }
+  }
+  const encoded = search.toString();
+  return encoded ? `?${encoded}` : "";
+}
+async function readServerDetail(response) {
+  try {
+    return await response.json();
+  } catch {
+    return void 0;
+  }
+}
+async function throwApiError(path, response) {
+  throw new MatrxApiError({
+    status: response.status,
+    path,
+    serverDetail: await readServerDetail(response)
+  });
+}
+async function requestJson(transport, path, options) {
+  const hasBody = options.method !== "GET" && options.body !== void 0;
+  const response = await transport.fetch(path, {
+    method: options.method,
+    headers: hasBody ? { "Content-Type": "application/json" } : {},
+    ...hasBody ? { body: JSON.stringify(options.body) } : {},
+    ...options.signal ? { signal: options.signal } : {}
+  });
+  if (!response.ok) return throwApiError(path, response);
+  return await response.json();
+}
+function toRunHandle(response, options) {
+  return {
+    requestId: response.headers.get("X-Request-ID"),
+    conversationId: response.headers.get("X-Conversation-ID"),
+    events: readMatrxNdjsonStream(response.body, {
+      ...options.signal ? { signal: options.signal } : {},
+      ...options.maxReadAhead !== void 0 ? { maxReadAhead: options.maxReadAhead } : {},
+      ...options.onMalformedLine ? { onMalformedLine: options.onMalformedLine } : {},
+      ...options.onUnknownEnvelope ? { onUnknownEnvelope: options.onUnknownEnvelope } : {},
+      ...options.onValidEnvelope ? { onValidEnvelope: options.onValidEnvelope } : {}
+    }),
+    response
+  };
+}
+async function requestStream(transport, path, options) {
+  const hasBody = options.method !== "GET" && options.body !== void 0;
+  const response = await transport.fetch(path, {
+    method: options.method,
+    headers: {
+      ...hasBody ? { "Content-Type": "application/json" } : {},
+      ...options.headers
+    },
+    ...hasBody ? { body: JSON.stringify(options.body) } : {},
+    ...options.signal ? { signal: options.signal } : {}
+  });
+  if (!response.ok) return throwApiError(path, response);
+  if (!response.body) {
+    throw new MatrxApiError({
+      status: response.status,
+      path,
+      serverDetail: { code: "missing_response_body" },
+      message: "The streaming response carried no body."
+    });
+  }
+  return response;
+}
+
+// matrx/run.ts
+async function streamCall(transport, path, body, options) {
+  const response = await requestStream(transport, path, {
+    method: "POST",
+    // This client IS the streaming path — `stream: true` always, last so a
+    // caller-supplied value can never flip the response off NDJSON.
+    body: { ...body, stream: true },
+    ...options.signal ? { signal: options.signal } : {}
+  });
+  return toRunHandle(response, options);
+}
+function startMandateRun(transport, mandateKey, request, options = {}) {
+  return streamCall(
+    transport,
+    `/ai/mandates/${encodePathSegment(mandateKey)}`,
+    request,
+    options
+  );
+}
+function cancelAgentRun(transport, requestId, options = {}) {
+  const query = buildQuery(
+    options.mode === "interrupt" ? { mode: "interrupt" } : {}
+  );
+  return requestJson(
+    transport,
+    `/ai/cancel/${encodePathSegment(requestId)}${query}`,
+    {
+      method: "POST",
+      ...options.signal ? { signal: options.signal } : {}
+    }
+  );
+}
+
+// stream/sse.ts
+var FRAME_SEPARATOR = /\r\n\r\n|\n\n|\r\r/;
+var LINE_SEPARATOR = /\r\n|\n|\r/;
+function parseMatrxSseFrame(frame) {
+  let event = "message";
+  let id = null;
+  const dataLines = [];
+  let sawData = false;
+  for (const line of frame.split(LINE_SEPARATOR)) {
+    if (line.startsWith(":")) continue;
+    if (line.startsWith("event:")) event = line.slice(6).trim();
+    else if (line.startsWith("data:")) {
+      sawData = true;
+      dataLines.push(line.slice(5).replace(/^ /, ""));
+    } else if (line.startsWith("id:")) id = line.slice(3).trim();
+  }
+  const seqCandidate = id !== null && id !== "" ? Number(id) : NaN;
+  const seq = Number.isSafeInteger(seqCandidate) && seqCandidate >= 0 ? seqCandidate : null;
+  return { event, id, seq, data: sawData ? dataLines.join("\n") : null };
+}
+function createMatrxSseFramer() {
+  let buffer = "";
+  return {
+    push(chunk) {
+      buffer += chunk;
+      const frames = [];
+      for (; ; ) {
+        const sep = FRAME_SEPARATOR.exec(buffer);
+        if (sep === null) break;
+        const frame = buffer.slice(0, sep.index);
+        buffer = buffer.slice(sep.index + sep[0].length);
+        frames.push(parseMatrxSseFrame(frame));
+      }
+      return frames;
+    },
+    flush() {
+      const rest = buffer;
+      buffer = "";
+      return { incomplete: rest.length > 0 ? rest : null };
+    }
+  };
+}
+async function* readMatrxSseStream(stream, options = {}) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  const framer = createMatrxSseFramer();
+  try {
+    for (; ; ) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      const frames = framer.push(decoder.decode(value, { stream: true }));
+      for (const frame of frames) yield frame;
+    }
+    const tail = framer.push(decoder.decode());
+    for (const frame of tail) yield frame;
+    const { incomplete } = framer.flush();
+    if (incomplete !== null) options.onIncomplete?.(incomplete);
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// matrx/operations.ts
+var RUNTIME_STATUSES = /* @__PURE__ */ new Set([
+  "pending",
+  "running",
+  "paused",
+  "waiting_input",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+async function getRuntimeOperationStatus(transport, requestId, options = {}) {
+  try {
+    return await requestJson(
+      transport,
+      `/runtime/operations/${encodePathSegment(requestId)}`,
+      { method: "GET", ...options.signal ? { signal: options.signal } : {} }
+    );
+  } catch (error) {
+    if (error instanceof MatrxApiError && error.status === 404) return null;
+    throw error;
+  }
+}
+function parseEndStatus(data) {
+  if (data === null) return null;
+  try {
+    const parsed = JSON.parse(data);
+    if (typeof parsed === "object" && parsed !== null && typeof parsed.status === "string") {
+      const status = parsed.status;
+      return RUNTIME_STATUSES.has(status) ? status : null;
+    }
+  } catch {
+  }
+  return null;
+}
+async function* followRuntimeOperationEvents(transport, executionId, options = {}) {
+  let cursor = options.lastEventSeq ?? 0;
+  const headers = { Accept: "text/event-stream" };
+  if (cursor > 0) headers["Last-Event-ID"] = String(cursor);
+  const response = await requestStream(
+    transport,
+    `/runtime/executions/${encodePathSegment(executionId)}/events/stream`,
+    {
+      method: "GET",
+      headers,
+      ...options.signal ? { signal: options.signal } : {}
+    }
+  );
+  const frames = readMatrxSseStream(
+    response.body,
+    options.onIncomplete ? { onIncomplete: options.onIncomplete } : {}
+  );
+  for await (const frame of frames) {
+    if (frame.event === "end") {
+      yield { type: "end", status: parseEndStatus(frame.data), cursor };
+      return;
+    }
+    if (frame.event === "execution_event" && frame.data !== null) {
+      let event;
+      try {
+        event = JSON.parse(frame.data);
+      } catch (error) {
+        options.onMalformedFrame?.(frame, error);
+        yield { type: "liveness", cursor };
+        continue;
+      }
+      if (frame.seq !== null && frame.seq > cursor) cursor = frame.seq;
+      yield { type: "event", event, seq: frame.seq, cursor };
+      continue;
+    }
+    yield { type: "liveness", cursor };
+  }
+}
+async function followRuntimeOperationToEnd(transport, executionId, options) {
+  const stallTimeoutMs = options.stallTimeoutMs ?? 45e3;
+  const reconnectLimit = options.reconnectLimit ?? 60;
+  const reconnectDelayMs = options.reconnectDelayMs ?? 2e3;
+  const outer = options.signal;
+  let cursor = options.lastEventSeq ?? 0;
+  let failures = 0;
+  while (!outer?.aborted && failures < reconnectLimit) {
+    const attempt = new AbortController();
+    const onOuterAbort = () => attempt.abort();
+    outer?.addEventListener("abort", onOuterAbort, { once: true });
+    let stallTimer = null;
+    const armStall = () => {
+      if (stallTimer !== null) clearTimeout(stallTimer);
+      stallTimer = setTimeout(() => attempt.abort(), stallTimeoutMs);
+    };
+    try {
+      const items = followRuntimeOperationEvents(transport, executionId, {
+        lastEventSeq: cursor,
+        signal: attempt.signal,
+        ...options.onMalformedFrame ? { onMalformedFrame: options.onMalformedFrame } : {}
+      });
+      armStall();
+      for await (const item of items) {
+        armStall();
+        failures = 0;
+        cursor = item.cursor;
+        if (item.type === "end") {
+          return { ended: true, status: item.status };
+        }
+        if (item.type === "event") {
+          options.onEvent(item.event, item.seq);
+        }
+      }
+      failures += 1;
+    } catch (error) {
+      if (outer?.aborted) break;
+      failures += 1;
+      options.onAttemptError?.(error);
+    } finally {
+      if (stallTimer !== null) clearTimeout(stallTimer);
+      outer?.removeEventListener("abort", onOuterAbort);
+    }
+    if (!outer?.aborted && failures < reconnectLimit) {
+      await new Promise((r) => setTimeout(r, reconnectDelayMs));
+    }
+  }
+  return { ended: false, status: null };
+}
+async function rejoinRuntimeOperation(transport, requestId, options = {}) {
+  const response = await requestStream(
+    transport,
+    `/runtime/operations/${encodePathSegment(requestId)}/rejoin`,
+    {
+      method: "POST",
+      // The route takes no body model; the reference client posts an empty
+      // JSON object. Match it so proxies see an ordinary JSON POST.
+      body: {},
+      ...options.signal ? { signal: options.signal } : {}
+    }
+  );
+  return toRunHandle(response, options);
+}
+
+// content-transfer/index.ts
+var SupersededRunError = class extends Error {
+  constructor() {
+    super("A newer AI preparation started before this result settled.");
+  }
+};
+function resolve(value) {
+  return typeof value === "function" ? value() : value;
+}
+function deepFreeze(value) {
+  if (ArrayBuffer.isView(value)) return value;
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const nested of Object.values(value)) deepFreeze(nested);
+  }
+  return value;
+}
+function isDeepFrozen(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (!value || typeof value !== "object" || ArrayBuffer.isView(value))
+    return true;
+  if (seen.has(value)) return true;
+  seen.add(value);
+  return Object.isFrozen(value) && Object.values(value).every((nested) => isDeepFrozen(nested, seen));
+}
+function descriptionForCoverage(snapshot, draft) {
+  const { coverage } = snapshot;
+  const total = coverage.total === null ? "unknown total" : `${coverage.total} total`;
+  const offered = draft.payload.kind === "rows" ? `${draft.payload.rows.length} prepared rows` : "one prepared document";
+  return `snapshot ${coverage.status}: ${coverage.included} included, ${total}; offered ${offered} from ${draft.sourceId}@${draft.sourceRevision}, draft revision ${draft.revision}${coverage.reason ? `; ${coverage.reason}` : ""}`;
+}
+function descriptionForOmissions(draft) {
+  if (draft.omissions.length === 0)
+    return "No pre-AI exclusions or reductions were recorded in this prepared draft.";
+  return draft.omissions.map(
+    (o) => `${o.path || "document"}: ${o.reason}${o.count === void 0 ? "" : ` (${o.count})`}`
+  ).join("; ");
+}
+function visibleAssistantText(content) {
+  if (typeof content === "string") return content.trim() || null;
+  if (!Array.isArray(content)) return null;
+  const parts = content.flatMap((part) => {
+    if (!part || typeof part !== "object" || Array.isArray(part)) return [];
+    const block = part;
+    return block.type === "text" && typeof block.text === "string" ? [block.text] : [];
+  });
+  return parts.join("\n\n").trim() || null;
+}
+function responseMessageId(metadata) {
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata))
+    return null;
+  const value = metadata.response_message_id;
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function draftFromAssistant(source, text, identity) {
+  const edited = (0, import_content_transfer.editDraft)(source, { kind: "markdown", text });
+  const reducedBy = (0, import_content_transfer.serialize)(source, "markdown").plainText.length - text.length;
+  return deepFreeze({
+    ...edited,
+    manuallyEdited: source.manuallyEdited,
+    omissions: [
+      ...edited.omissions,
+      ...reducedBy > 0 ? [
+        {
+          path: "/ai/content",
+          reason: "truncated",
+          count: reducedBy
+        }
+      ] : []
+    ],
+    provenance: [
+      ...edited.provenance.slice(0, -1),
+      {
+        kind: "ai",
+        operationId: identity.requestId,
+        description: `AI preparation of ${source.sourceId}@${source.sourceRevision}; source omissions remain separately recorded.`
+      }
+    ]
+  });
+}
+function assertCoherent(snapshot, draft) {
+  if (!isDeepFrozen(snapshot) || !isDeepFrozen(draft))
+    throw new Error(
+      "Alchemy requires the deeply frozen Snapshot and Draft produced by @ai-matrx/kit/content-transfer."
+    );
+  if (draft.snapshotId !== snapshot.id || draft.sourceId !== snapshot.sourceId || draft.sourceRevision !== snapshot.revision)
+    throw new Error(
+      "The prepared draft does not belong to this captured snapshot."
+    );
+}
+function assertIdentitySource(identity, source) {
+  if (!isDeepFrozen(source))
+    throw new Error(
+      "Alchemy recovery requires the deeply frozen Draft produced by @ai-matrx/kit/content-transfer."
+    );
+  if (identity.snapshotId !== source.snapshotId || identity.sourceId !== source.sourceId || identity.sourceRevision !== source.sourceRevision || identity.draftRevision !== source.revision) {
+    throw new Error(
+      "The recovery identity does not belong to this frozen prepared draft."
+    );
+  }
+}
+function errorMessage(error) {
+  return error instanceof Error && error.message ? error.message : "Unknown stream failure.";
+}
+function detached(identity, message) {
+  return { status: "detached", identity, draft: null, message };
+}
+async function consume(handle, afterAwait, onEvent) {
+  for await (const event of handle.events) {
+    afterAwait();
+    onEvent?.(event);
+  }
+  afterAwait();
+}
+function createMatrxContentTransferAdapter(options) {
+  let latestGeneration = 0;
+  const transport = () => resolve(options.transport);
+  const organizationId = () => resolve(options.organizationId);
+  let activeGeneration = null;
+  const inGeneration = async (outer, run) => {
+    activeGeneration?.abort();
+    const controller = new AbortController();
+    activeGeneration = controller;
+    const generation = ++latestGeneration;
+    const abort = () => controller.abort(outer?.reason);
+    if (outer?.aborted) abort();
+    else outer?.addEventListener("abort", abort, { once: true });
+    try {
+      return await run(generation, controller.signal);
+    } finally {
+      outer?.removeEventListener("abort", abort);
+      if (activeGeneration === controller) activeGeneration = null;
+    }
+  };
+  const check = (generation) => {
+    if (generation !== latestGeneration) throw new SupersededRunError();
+    activeGeneration?.signal.throwIfAborted();
+  };
+  const readVisibleAssistant = async (identity, generation) => {
+    const requestResult = await options.supabase.schema("chat").from("request").select("id, metadata, iteration").eq("user_request_id", identity.requestId).eq("conversation_id", identity.conversationId).is("deleted_at", null).not("metadata->>response_message_id", "is", null).order("iteration", { ascending: false }).limit(1);
+    check(generation);
+    if (requestResult.error)
+      throw new Error(
+        requestResult.error.message || "Could not read the persisted AI request."
+      );
+    const messageId = responseMessageId(requestResult.data?.[0]?.metadata);
+    if (!messageId)
+      throw new Error(
+        "The completed AI request has no persisted response message link yet."
+      );
+    const messageResult = await options.supabase.schema("chat").from("message").select("id, content").eq("id", messageId).eq("conversation_id", identity.conversationId).eq("role", "assistant").is("deleted_at", null).eq("is_visible_to_user", true).limit(1);
+    check(generation);
+    if (messageResult.error)
+      throw new Error(
+        messageResult.error.message || "Could not read the prepared AI result."
+      );
+    const exact = messageResult.data?.find((row) => row.id === messageId);
+    return exact ? visibleAssistantText(exact.content) : null;
+  };
+  const locate = async (identity, generation, signal) => {
+    const result = await getRuntimeOperationStatus(
+      transport(),
+      identity.requestId,
+      signal ? { signal } : {}
+    );
+    check(generation);
+    const exact = result?.operations.find(
+      (operation) => operation.request_id === identity.requestId && operation.link_kind === "conversation" && operation.link_id === identity.conversationId
+    ) ?? null;
+    if (!exact && result?.operation_count)
+      throw new Error(
+        "The durable operation identity does not match this stored conversation."
+      );
+    return exact;
+  };
+  const recoverInGeneration = async (generation, identity, source, onProgress, signal) => {
+    try {
+      assertIdentitySource(identity, source);
+      check(generation);
+      let operation = await locate(identity, generation, signal);
+      if (!operation)
+        return {
+          status: "unavailable",
+          identity,
+          draft: null,
+          message: "The durable operation is not available to this account yet."
+        };
+      let resolvedIdentity = deepFreeze({
+        ...identity,
+        executionId: operation.execution_id
+      });
+      if (!operation.is_terminal) {
+        onProgress?.({ ...resolvedIdentity, status: operation.status });
+        const settled = await followRuntimeOperationToEnd(
+          transport(),
+          operation.execution_id,
+          {
+            ...signal ? { signal } : {},
+            lastEventSeq: operation.last_event_seq,
+            onEvent: (event, seq) => {
+              if (generation !== latestGeneration || signal?.aborted) return;
+              options.onRuntimeEvent?.(event, seq);
+            }
+          }
+        );
+        check(generation);
+        if (!settled.ended || settled.status === null)
+          return detached(
+            resolvedIdentity,
+            "The lifecycle stream detached; the operation remains recoverable from this request."
+          );
+        const refreshed = await locate(identity, generation, signal);
+        if (!refreshed)
+          return detached(
+            resolvedIdentity,
+            "The settled operation is temporarily unavailable; retry recovery with this request."
+          );
+        operation = refreshed;
+        resolvedIdentity = deepFreeze({
+          ...identity,
+          executionId: operation.execution_id
+        });
+      }
+      onProgress?.({ ...resolvedIdentity, status: operation.status });
+      if (operation.status === "cancelled")
+        return {
+          status: "cancelled",
+          identity: resolvedIdentity,
+          draft: null,
+          message: "The AI preparation was cancelled. Any partial output was not applied."
+        };
+      if (operation.status !== "completed")
+        return {
+          status: "failed",
+          identity: resolvedIdentity,
+          draft: null,
+          message: typeof operation.error?.message === "string" ? operation.error.message : "The AI preparation did not complete."
+        };
+      const text = await readVisibleAssistant(resolvedIdentity, generation);
+      check(generation);
+      if (!text)
+        return {
+          status: "unavailable",
+          identity: resolvedIdentity,
+          draft: null,
+          message: "The exact persisted assistant result is not visible yet."
+        };
+      const draft = draftFromAssistant(source, text, resolvedIdentity);
+      check(generation);
+      return {
+        status: "completed",
+        identity: resolvedIdentity,
+        draft,
+        message: null
+      };
+    } catch (error) {
+      return detached(
+        identity,
+        error instanceof SupersededRunError ? error.message : `Recovery detached: ${errorMessage(error)} You can retry with this request.`
+      );
+    }
+  };
+  return {
+    async launch(input) {
+      return inGeneration(input.signal, async (generation, signal) => {
+        assertCoherent(input.snapshot, input.draft);
+        const conversation = newStoredConversationStart();
+        input.onProgress?.({
+          requestId: null,
+          conversationId: conversation.conversation_id,
+          executionId: null,
+          status: "starting"
+        });
+        const preparedContent = (0, import_content_transfer.serialize)(input.draft, "markdown").plainText;
+        let identity = null;
+        try {
+          const handle = await startMandateRun(
+            transport(),
+            MANDATE_KEYS.alchemy__prepare_content,
+            {
+              ...conversation,
+              organization_id: organizationId(),
+              source_app: options.sourceApp,
+              source_feature: `mandate:${MANDATE_KEYS.alchemy__prepare_content}`,
+              user_input: input.instruction,
+              variables: {
+                prepared_content: preparedContent,
+                content_label: input.snapshot.label,
+                coverage_description: descriptionForCoverage(
+                  input.snapshot,
+                  input.draft
+                ),
+                omission_description: descriptionForOmissions(input.draft)
+              }
+            },
+            { signal }
+          );
+          if (!handle.requestId)
+            throw new Error(
+              "The Matrx server did not return X-Request-ID for the preparation run."
+            );
+          identity = deepFreeze({
+            requestId: handle.requestId,
+            conversationId: handle.conversationId ?? conversation.conversation_id,
+            executionId: null,
+            snapshotId: input.snapshot.id,
+            sourceId: input.draft.sourceId,
+            sourceRevision: input.draft.sourceRevision,
+            draftRevision: input.draft.revision
+          });
+          assertIdentitySource(identity, input.draft);
+          check(generation);
+          input.onProgress?.({ ...identity, status: "streaming" });
+          await consume(handle, () => check(generation), options.onStreamEvent);
+          check(generation);
+          const result = await recoverInGeneration(
+            generation,
+            identity,
+            input.draft,
+            input.onProgress,
+            signal
+          );
+          check(generation);
+          return result;
+        } catch (error) {
+          if (!identity) throw error;
+          return detached(
+            identity,
+            error instanceof SupersededRunError ? error.message : `The local stream detached after the server accepted the request: ${errorMessage(error)} Server work was not cancelled; retry recovery with this request.`
+          );
+        }
+      });
+    },
+    async recover(identity, source, onProgress, signal) {
+      return inGeneration(signal, async (generation, signal2) => {
+        assertIdentitySource(identity, source);
+        const result = await recoverInGeneration(
+          generation,
+          identity,
+          source,
+          onProgress,
+          signal2
+        );
+        return generation === latestGeneration ? result : detached(
+          identity,
+          "A newer AI preparation started before this result settled."
+        );
+      });
+    },
+    async rejoin(identity, source, onProgress, signal) {
+      return inGeneration(signal, async (generation, signal2) => {
+        assertIdentitySource(identity, source);
+        try {
+          const handle = await rejoinRuntimeOperation(
+            transport(),
+            identity.requestId,
+            signal2 ? { signal: signal2 } : {}
+          );
+          check(generation);
+          await consume(handle, () => check(generation), options.onStreamEvent);
+          check(generation);
+        } catch (error) {
+          if (!(error instanceof MatrxApiError && error.status === 409))
+            return detached(
+              identity,
+              error instanceof SupersededRunError ? error.message : `Live rejoin detached: ${errorMessage(error)} You can retry durable recovery with this request.`
+            );
+        }
+        const result = await recoverInGeneration(
+          generation,
+          identity,
+          source,
+          onProgress,
+          signal2
+        );
+        return generation === latestGeneration ? result : detached(
+          identity,
+          "A newer AI preparation started before this result settled."
+        );
+      });
+    },
+    cancel(requestId) {
+      return cancelAgentRun(transport(), requestId);
+    }
+  };
+}
+
+// content-transfer/react/index.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function createAiSession(options, onProgress) {
+  const adapter = createMatrxContentTransferAdapter(options);
+  let retainedIdentity = null;
+  let retainedSource = null;
+  let activeRequestId = null;
+  let latestRun = 0;
+  let pendingRequest = null;
+  const session = {
+    supports: (_snapshot) => true,
+    fork: () => createAiSession(options, onProgress),
+    async run({ snapshot, draft, instruction, signal }) {
+      const run = ++latestRun;
+      activeRequestId = null;
+      retainedIdentity = null;
+      retainedSource = Object.freeze({ snapshot, draft });
+      let resolveRequest;
+      const request = {
+        promise: new Promise((resolve2) => {
+          resolveRequest = resolve2;
+        }),
+        resolve: resolveRequest
+      };
+      pendingRequest = request;
+      try {
+        const result = await adapter.launch({
+          snapshot,
+          draft,
+          instruction,
+          signal,
+          onProgress: (progress) => {
+            if (run !== latestRun) return;
+            onProgress?.(progress);
+            if (!progress.requestId) return;
+            activeRequestId = progress.requestId;
+            request.resolve(progress.requestId);
+            retainedIdentity = Object.freeze({
+              requestId: progress.requestId,
+              conversationId: progress.conversationId,
+              executionId: progress.executionId,
+              snapshotId: snapshot.id,
+              sourceId: draft.sourceId,
+              sourceRevision: draft.sourceRevision,
+              draftRevision: draft.revision
+            });
+          }
+        });
+        if (run === latestRun) {
+          retainedIdentity = result.identity ?? retainedIdentity;
+          activeRequestId = result.identity?.requestId ?? activeRequestId;
+          request.resolve(activeRequestId);
+        }
+        if (result.status !== "completed" || !result.draft)
+          throw new Error(
+            result.message || "AI preparation did not return a draft."
+          );
+        return result.draft;
+      } finally {
+        request.resolve(null);
+        if (run === latestRun && pendingRequest === request) {
+          pendingRequest = null;
+        }
+      }
+    },
+    async recover({ snapshot, draft, signal }) {
+      const recoveryRun = ++latestRun;
+      if (!retainedIdentity)
+        throw new Error(
+          "No recoverable AI preparation exists in this workspace session."
+        );
+      if (!retainedSource || retainedIdentity.snapshotId !== snapshot.id || retainedSource.snapshot.id !== snapshot.id || retainedSource.draft.snapshotId !== draft.snapshotId || retainedSource.draft.sourceId !== draft.sourceId || retainedSource.draft.sourceRevision !== draft.sourceRevision || retainedSource.draft.revision !== draft.revision) {
+        throw new Error(
+          "The recoverable AI preparation belongs to a different source draft."
+        );
+      }
+      const result = await adapter.rejoin(
+        retainedIdentity,
+        retainedSource.draft,
+        (progress) => {
+          if (recoveryRun === latestRun) onProgress?.(progress);
+        },
+        signal
+      );
+      if (recoveryRun !== latestRun)
+        throw new Error("A newer AI preparation started before recovery settled.");
+      retainedIdentity = result.identity ?? retainedIdentity;
+      activeRequestId = retainedIdentity.requestId;
+      if (result.status !== "completed" || !result.draft)
+        throw new Error(
+          result.message || "AI preparation recovery did not return a draft."
+        );
+      return result.draft;
+    },
+    async cancel() {
+      const requestId = activeRequestId ?? (pendingRequest ? await pendingRequest.promise : null);
+      if (!requestId)
+        throw new Error(
+          "The current AI preparation ended before the server returned a request ID; no server cancellation was reported."
+        );
+      await adapter.cancel(requestId);
+    }
+  };
+  return session;
+}
+function MatrxContentTransferProvider({
+  children,
+  capabilities,
+  onProgress,
+  ...options
+}) {
+  const ai = React.useMemo(
+    () => createAiSession(options, onProgress),
+    [
+      options.transport,
+      options.supabase,
+      options.organizationId,
+      options.sourceApp,
+      options.onStreamEvent,
+      options.onRuntimeEvent,
+      onProgress
+    ]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_content_transfer2.ContentTransferCapabilitiesProvider, { value: { ...capabilities, ai }, children });
+}
+//# sourceMappingURL=index.cjs.map