Skip to main content

qualia_core_db/poet_host/invoke/
shed_registry.rs

1//! POET Shed Registry & Cross-Container ToolChain Execution.
2//!
3//! Provides the unified POET Shed environment: Constructs (observer lenses),
4//! Manifolds (17 work surfaces + 17 dimensional axes), Containers (cross-compatible
5//! workspaces), Toolboxes, and ToolChains backed by QualiaDB specialized libraries.
6//! Follows AGENTS.md §0-B (< 485 lines).
7
8use super::args;
9use super::ids;
10use vibe::{Diagnostic, Span, Value};
11
12// ── Static Shed Constructs ──────────────────────────────────────────────────
13
14pub struct ShedConstruct {
15    pub id: &'static str,
16    pub title: &'static str,
17    pub manifolds: &'static [&'static str],
18    pub default_toolboxes: &'static [&'static str],
19}
20
21pub const SHED_CONSTRUCTS: &[ShedConstruct] = &[
22    ShedConstruct { id: "poet", title: "POET Core HyperCanvas", manifolds: &["studio-bay", "vibe", "media"], default_toolboxes: &["StudioAndHypermedia", "ComputationalGeometry"] },
23    ShedConstruct { id: "research-lab", title: "Autonomous Scientific Research Lab", manifolds: &["research", "datasets", "knowledge"], default_toolboxes: &["StatisticsMlAndResearch", "ScienceChemistryClinical"] },
24    ShedConstruct { id: "studio", title: "Cross-Domain Multi-Disciplinary Studio", manifolds: &["studio-bay", "studio", "media"], default_toolboxes: &["StudioAndHypermedia", "GeometricAlgebra"] },
25    ShedConstruct { id: "health", title: "Clinical & Genomic Medicine Laboratory", manifolds: &["health", "anatomy", "datasets"], default_toolboxes: &["ScienceChemistryClinical", "StatisticsMlAndResearch"] },
26    ShedConstruct { id: "rights", title: "Human Rights & Cooperative Commons", manifolds: &["rights", "sanctuary", "social"], default_toolboxes: &["EconomicsAndGovernance", "LogicAndSemantics"] },
27    ShedConstruct { id: "knowledge", title: "Ontological Knowledge Graph", manifolds: &["knowledge", "ontology"], default_toolboxes: &["LogicAndSemantics", "StatisticsMlAndResearch"] },
28    ShedConstruct { id: "projects", title: "Collaborative Work & Engineering Projects", manifolds: &["projects", "studio"], default_toolboxes: &["EconomicsAndGovernance", "MathCasAndSolvers"] },
29    ShedConstruct { id: "geometry-lab", title: "N-Dimensional Volumetric Geometry Lab", manifolds: &["studio", "media"], default_toolboxes: &["ComputationalGeometry", "GeometricAlgebra"] },
30    ShedConstruct { id: "economics-commons", title: "Cooperative Economics & Market Design", manifolds: &["social", "communications"], default_toolboxes: &["EconomicsAndGovernance", "MathCasAndSolvers"] },
31    ShedConstruct { id: "logic-sentinel", title: "Formal Deontic & Sentinel Logic Workbench", manifolds: &["ontology", "rights"], default_toolboxes: &["LogicAndSemantics", "MathCasAndSolvers"] },
32];
33
34// ── Static Shed Toolboxes ───────────────────────────────────────────────────
35
36pub const SHED_TOOLBOXES: &[(&str, &[&str])] = &[
37    ("ComputationalGeometry", &["ComputationalGeometry.hull2", "ComputationalGeometry.triangulate_polygon", "ComputationalGeometry.heat_geodesics", "ComputationalGeometry.svo_raycast", "ComputationalGeometry.morton_encode_3d", "ComputationalGeometry.sdf_smooth", "ComputationalGeometry.space_colonize_3d", "ComputationalGeometry.solar_track", "ComputationalGeometry.poisson_disk_3d", "ComputationalGeometry.pbd_step", "ComputationalGeometry.dqs_skin", "ComputationalGeometry.boolean_union_area"]),
38    ("GeometricAlgebra", &["GeometricAlgebra.geometric_product", "GeometricAlgebra.outer_product", "GeometricAlgebra.rotor_from_angle_axis", "GeometricAlgebra.apply_rotor", "GeometricAlgebra.translator_from_displacement"]),
39    ("MathCasAndSolvers", &["LinearAlgebra.solve_linear_system", "LinearAlgebra.svd", "LinearAlgebra.eigen_symmetric", "SymbolicAlgebra.differentiate", "SymbolicAlgebra.integrate_definite", "SymbolicAlgebra.taylor_coefficients", "SymbolicAlgebra.to_quins", "SymbolicODE.solve_linear_second_order", "Calculus.stormer_verlet_step", "NumberTheory.crt", "SpecialFunctions.bessel_j", "Interpolation.lagrange_eval"]),
40    ("LogicAndSemantics", &["Deontic.evaluate", "Epistemic.evaluate", "Paraconsistent.route", "LTL.evaluate_trace", "N3.evaluate", "SHACL.validate", "SHACL.extensions", "GraphDatabase.sparql", "GraphReasoning.spreading_activation", "FuzzyQuery.top_k", "DescriptionLogic.subsumes", "ASP.enumerate", "Causal.caused"]),
41    ("EconomicsAndGovernance", &["Econ.black_scholes", "Econ.capm_expected_return", "Econ.gini", "Econ.atkinson", "Econ.rawlsian_welfare", "Econ.solow_steady_state", "Econ.ramsey_steady_state", "Econ.cournot_duopoly", "Econ.vcg_payment", "Econ.social_cost_of_carbon", "Econ.leontief_inverse", "Econ.interbank_clearing", "Econ.accounting_balance", "CooperativeDelegation.permits", "CooperativeWork.board_project", "Agency.evaluate", "Sentinel.gate"]),
42    ("ScienceChemistryClinical", &["Physics.molecular_dynamics", "Physics.cfd_step", "Physics.emf_field_grid_3d", "Physics.quantum_states_1d", "Chemistry.evaluate_eri", "Chemistry.lda_exchange", "Chemistry.sto3g_h2", "Chemistry.boys_function", "Bioinformatics.align", "ClinicalRisk.framingham", "ClinicalRisk.cha2ds2_vasc", "ClinicalRisk.score2", "ClinicalRisk.check_drug_interaction", "EngineeringAnalysis.fem_static", "Simulation.soil_compaction", "Simulation.fire_ecology", "Cosmic.flrw_redshift"]),
43    ("StatisticsMlAndResearch", &["Statistics.one_way_anova", "Statistics.mann_whitney_u", "Statistics.fisher_distance", "Statistics.kl_bregman_form", "Statistics.mvn_mle", "MachineLearning.pca", "MachineLearning.kmeans_fit", "MachineLearning.random_forest_fit_classifier", "MachineLearning.gp_fit", "MachineLearning.hmm_baum_welch", "NLP.graphrag_query", "NLP.coref_resolve", "Research.new_investigation", "Research.infer_dark_link", "Research.reconcile_perspectives", "Inference.run_transformer"]),
44    ("StudioAndHypermedia", &["Document.create", "Document.layout_paragraph", "Sheet.eval_formula", "Deck.slide_layout", "Pdf.preflight_a11y", "Raster.cms_convert", "RawDevelop.demosaic", "Vector.path_boolean", "Cad.sketch_constrain", "Cad.brep_solid", "Timeline.master_lufs", "WgslForge.generate", "WgslForge.roofline", "Studio.edit", "Studio.inspect", "Studio.import", "Studio.export", "Scene.render", "Audio.oscillator", "Video.colour_grade", "HID.poll"]),
45];
46
47const BASE_FAMILIES: &[(&str, &[&str])] = &[
48    ("Core", &["Select", "Transform", "Pen", "Brush", "Eraser", "Measure", "Eyedropper", "Slice"]),
49    ("Constructs", &["Container", "ManifoldPortal", "NestedLink", "TimelineTrack", "ShaderNode", "ConstraintSolver"]),
50    ("Manifolds", &["Spatial", "Temporal", "Acoustic", "RF", "Magnetic", "Cyber", "Hardware", "Logical", "Agentic", "Socio", "Political", "Legal", "Economic", "Bio", "Thermal", "Ecological", "Relativistic"]),
51    ("Agents", &["Planner", "Synthesizer", "Verifier", "Archivist", "Choreographer", "SentinelGuard"]),
52    ("Ecosystems", &["EcoPunk", "GameDemo", "CatchmentCommons", "BilateralMicroCommons", "CivicObservatory"]),
53    ("Applications", &["DocumentStudio", "SheetStudio", "DeckStudio", "PdfStudio", "RasterStudio", "RawDevelopStudio", "VectorStudio", "GenerativeStudio", "CadStudio", "VideoStudio", "AudioStudio"]),
54    ("Services", &["PulseTransport", "Q42VolumeStore", "ShaclGate", "WgslForge", "LocalLlm"]),
55    ("Systems", &["SlgSentinel42MB", "WebGpuViewport", "HrtfAudio", "HidRingBuffer", "DeonticJudge"]),
56];
57
58#[inline]
59fn save_art(id: &str, domain: &str, title: &str, history_op: &str, props: &[(&str, &str)]) -> (u64, u64, u64) {
60    let mut art = super::studio_store::get_artifact(id).unwrap_or_else(|| super::studio_store::StudioArtifact::new(id, domain, title));
61    for (k, v) in props { art.properties.insert((*k).into(), (*v).into()); }
62    art.history.push(history_op.into());
63    let quins = art.compile_to_quins();
64    let (did, clock, qcount) = (art.did_q42, art.lamport_clock as u64, quins.len() as u64);
65    super::studio_store::upsert_artifact(art);
66    (did, clock, qcount)
67}
68
69/// Recommends a toolbox category, construct ID, and default toolchain CSV for a given container kind and manifold.
70pub fn recommend_for_context(container_kind: &str, manifold: &str) -> (&'static str, &'static str, &'static str) {
71    let (ck, mf) = (container_kind.trim().to_ascii_lowercase(), manifold.trim().to_ascii_lowercase());
72    match ck.as_str() {
73        "cad" => ("ComputationalGeometry", "studio", "Cad.sketch_constrain,Cad.brep_solid,Vector.extrude_3d"),
74        "spatial-3d" | "3d" => ("ComputationalGeometry", "geometry-lab", "ComputationalGeometry.hull2,WgslForge.generate"),
75        "shader" | "gpu" => ("StudioAndHypermedia", "geometry-lab", "WgslForge.generate,WgslForge.roofline,Poet.viewport_configure"),
76        "logic" | "proof" | "sparql" => ("LogicAndSemantics", "logic-sentinel", "Deontic.evaluate,SHACL.validate,N3.evaluate"),
77        "notebook" | "research" => ("StatisticsMlAndResearch", "research-lab", "Research.new_investigation,NLP.graphrag_query,Statistics.one_way_anova"),
78        "sheet" => ("StudioAndHypermedia", "studio", "Sheet.create,Sheet.eval_formula,Sheet.pivot_analyze"),
79        "economics" | "wallet" => ("EconomicsAndGovernance", "economics-commons", "Econ.accounting_balance,CooperativeWork.board_project"),
80        "social" => ("EconomicsAndGovernance", "rights", "CooperativeDelegation.permits,Social.gini"),
81        "document" => ("StudioAndHypermedia", "studio", "Document.create,Document.layout_paragraph,Document.proof_check"),
82        "deck" => ("StudioAndHypermedia", "studio", "Deck.create,Deck.slide_layout,Deck.export_pptx"),
83        "pdf" => ("StudioAndHypermedia", "studio", "Pdf.inspect_cos,Pdf.preflight_a11y,Pdf.redact_sign"),
84        "raster" => ("StudioAndHypermedia", "studio", "Raster.cms_convert,Raster.tone_curve,RawDevelop.demosaic"),
85        "vector" => ("StudioAndHypermedia", "studio", "Vector.path_boolean,Vector.bezier_offset,Vector.svg_compile"),
86        "timeline" => ("StudioAndHypermedia", "studio", "Timeline.scopes_analyze,Timeline.master_lufs,Timeline.dsp_chain"),
87        "simulation" => ("ScienceChemistryClinical", "research-lab", "Simulation.soil_compaction,Simulation.fire_ecology,Physics.cfd_step"),
88        "wire" => ("StudioAndHypermedia", "poet", "Poet.nested_link,Poet.inspector_bind"),
89        _ => match mf.as_str() {
90            "health" | "anatomy" => ("ScienceChemistryClinical", "health", "ClinicalRisk.score2,ClinicalRisk.framingham"),
91            "rights" | "sanctuary" => ("EconomicsAndGovernance", "rights", "Agency.evaluate,CooperativeDelegation.permits"),
92            "knowledge" | "ontology" => ("LogicAndSemantics", "knowledge", "GraphDatabase.sparql,SHACL.validate"),
93            _ => ("StudioAndHypermedia", "poet", "Document.create,Poet.export_bundle"),
94        },
95    }
96}
97
98// ── Vibe Invoke Handlers ────────────────────────────────────────────────────
99
100/// `Poet.toolchest_list` — lists Shed toolboxes, constructs, and tool families or creates custom items.
101pub fn toolchest_list(args_v: &Value, _span: Span) -> Result<Value, Diagnostic> {
102    let op = args::rec_str(args_v, "op").unwrap_or("list");
103
104    if op == "toolbox_create" {
105        let (t_id, lbl, cat) = (args::rec_str(args_v, "toolbox_id").unwrap_or("custom-toolbox"), args::rec_str(args_v, "label").unwrap_or("Custom Shed Toolbox"), args::rec_str(args_v, "category").unwrap_or("custom"));
106        let (tools, c_kind) = (args::rec_str(args_v, "tools").unwrap_or("custom.op"), args::rec_str(args_v, "container_kind").unwrap_or("any"));
107        let art_id = format!("toolbox:{t_id}");
108        let (did, clock, qcount) = save_art(&art_id, "Toolbox", lbl, "toolbox_create", &[("toolbox_id", t_id), ("category", cat), ("container_kind", c_kind), ("tools", tools)]);
109        return Ok(args::record([
110            ("status", Value::String("created".into())), ("op", Value::String("toolbox_create".into())),
111            ("id", Value::String(ids::POET_TOOLCHEST_LIST.into())), ("toolbox_id", Value::String(t_id.into())),
112            ("label", Value::String(lbl.into())), ("category", Value::String(cat.into())),
113            ("container_kind", Value::String(c_kind.into())), ("tools", Value::String(tools.into())),
114            ("did_q42", Value::U64(did)), ("lamport_clock", Value::U64(clock)), ("quin_count", Value::U64(qcount)),
115            ("shell", Value::String("poet".into())),
116        ]));
117    }
118
119    if op == "toolchain_create" {
120        let (tc_id, lbl) = (args::rec_str(args_v, "toolchain_id").unwrap_or("custom-toolchain"), args::rec_str(args_v, "label").unwrap_or("Custom ToolChain"));
121        let (t_kind, steps) = (args::rec_str(args_v, "target_kind").unwrap_or("any"), args::rec_str(args_v, "steps").unwrap_or("Document.create,Poet.export_bundle"));
122        let art_id = format!("toolchain:{tc_id}");
123        let (did, clock, qcount) = save_art(&art_id, "ToolChain", lbl, "toolchain_create", &[("toolchain_id", tc_id), ("target_kind", t_kind), ("steps", steps)]);
124        return Ok(args::record([
125            ("status", Value::String("created".into())), ("op", Value::String("toolchain_create".into())),
126            ("id", Value::String(ids::POET_TOOLCHEST_LIST.into())), ("toolchain_id", Value::String(tc_id.into())),
127            ("label", Value::String(lbl.into())), ("target_kind", Value::String(t_kind.into())),
128            ("steps", Value::String(steps.into())), ("did_q42", Value::U64(did)),
129            ("lamport_clock", Value::U64(clock)), ("quin_count", Value::U64(qcount)),
130            ("shell", Value::String("poet".into())),
131        ]));
132    }
133
134    let family = args::rec_str(args_v, "family").unwrap_or("all");
135    let mut matched = Vec::new();
136    let mut total_caps = 0u64;
137    for (fname, items) in BASE_FAMILIES.iter().chain(SHED_TOOLBOXES.iter()) {
138        total_caps += items.len() as u64;
139        if family.eq_ignore_ascii_case("all") || family.eq_ignore_ascii_case(fname) {
140            let item_vals: Vec<Value> = items.iter().map(|s| Value::String((*s).into())).collect();
141            matched.push(args::record([("family", Value::String((*fname).into())), ("count", Value::U64(item_vals.len() as u64)), ("items", Value::List(item_vals))]));
142        }
143    }
144
145    let constructs: Vec<Value> = SHED_CONSTRUCTS.iter().map(|c| {
146        let man_vals: Vec<Value> = c.manifolds.iter().map(|m| Value::String((*m).into())).collect();
147        let box_vals: Vec<Value> = c.default_toolboxes.iter().map(|b| Value::String((*b).into())).collect();
148        args::record([("id", Value::String(c.id.into())), ("title", Value::String(c.title.into())), ("manifolds", Value::List(man_vals)), ("default_toolboxes", Value::List(box_vals))])
149    }).collect();
150
151    let shed_boxes: Vec<Value> = SHED_TOOLBOXES.iter().map(|(tname, tools)| {
152        let tool_vals: Vec<Value> = tools.iter().map(|s| Value::String((*s).into())).collect();
153        args::record([("toolbox", Value::String((*tname).into())), ("tool_count", Value::U64(tool_vals.len() as u64)), ("tools", Value::List(tool_vals))])
154    }).collect();
155
156    let (rec_box, rec_construct, rec_chain) = recommend_for_context(args::rec_str(args_v, "container_kind").unwrap_or(""), args::rec_str(args_v, "manifold").unwrap_or(""));
157
158    Ok(args::record([
159        ("op", Value::String("toolchest_list".into())), ("id", Value::String(ids::POET_TOOLCHEST_LIST.into())),
160        ("filter", Value::String(family.into())), ("family_count", Value::U64(matched.len() as u64)),
161        ("families", Value::List(matched)), ("construct_count", Value::U64(constructs.len() as u64)),
162        ("constructs", Value::List(constructs)), ("shed_toolbox_count", Value::U64(shed_boxes.len() as u64)),
163        ("shed_toolboxes", Value::List(shed_boxes.clone())), ("toolbox_count", Value::U64(shed_boxes.len() as u64)),
164        ("toolboxes", Value::List(shed_boxes)), ("total_capabilities", Value::U64(total_caps)),
165        ("recommended_toolbox", Value::String(rec_box.into())), ("recommended_construct", Value::String(rec_construct.into())),
166        ("recommended_toolchain", Value::String(rec_chain.into())), ("shell", Value::String("poet".into())),
167    ]))
168}
169
170/// `Poet.manifold_inspect` — inspects a work-surface manifold or dimensional axis.
171pub fn manifold_inspect(args_v: &Value, span: Span) -> Result<Value, Diagnostic> {
172    let domain = args::rec_str(args_v, "domain").or_else(|| args::rec_str(args_v, "manifold")).ok_or_else(|| args::bad(span, "Poet.manifold_inspect needs domain"))?;
173
174    let (axis_index, unit, default_shader, graph_iri, toolboxes) = match domain.to_ascii_lowercase().as_str() {
175        "spatial" => (0u64, "qudt:Meter", "terrain_pbr_pom", "qualia:manifold:spatial", &["ComputationalGeometry", "GeometricAlgebra"][..]),
176        "temporal" => (1, "qudt:Second", "temporal_ripple", "qualia:manifold:temporal", &["StudioAndHypermedia"][..]),
177        "acoustic" => (2, "qudt:Decibel", "acoustic_cymatics", "qualia:manifold:acoustic", &["StudioAndHypermedia"][..]),
178        "rf" => (3, "qudt:Hertz", "emf_vector_field", "qualia:manifold:rf", &["ScienceChemistryClinical"][..]),
179        "magnetic" => (4, "qudt:Tesla", "plasma_confinement", "qualia:manifold:magnetic", &["ScienceChemistryClinical"][..]),
180        "cyber" => (5, "qudt:BitPerSecond", "cyber_lattice", "qualia:manifold:cyber", &["StudioAndHypermedia"][..]),
181        "hardware" => (6, "qudt:Watt", "silicon_die_thermal", "qualia:manifold:hardware", &["ScienceChemistryClinical"][..]),
182        "logical" => (7, "qualia:TruthDegree", "deontic_halo", "qualia:manifold:logical", &["LogicAndSemantics"][..]),
183        "agentic" => (8, "qualia:AgencyWeight", "swarm_boids", "qualia:manifold:agentic", &["StatisticsMlAndResearch"][..]),
184        "socio" => (9, "qualia:TrustMetric", "social_force_graph", "qualia:manifold:socio", &["EconomicsAndGovernance"][..]),
185        "political" => (10, "qualia:ConsensusRatio", "civic_voronoi", "qualia:manifold:political", &["EconomicsAndGovernance"][..]),
186        "legal" => (11, "qualia:HohfeldPosition", "jural_correlator", "qualia:manifold:legal", &["EconomicsAndGovernance", "LogicAndSemantics"][..]),
187        "economic" => (12, "qualia:UtilityUnit", "flow_sankey", "qualia:manifold:economic", &["EconomicsAndGovernance"][..]),
188        "bio" => (13, "qudt:BeatsPerMinute", "bioluminescent_mycelium", "qualia:manifold:bio", &["ScienceChemistryClinical"][..]),
189        "thermal" => (14, "qudt:Kelvin", "thermal_infrared", "qualia:manifold:thermal", &["ScienceChemistryClinical"][..]),
190        "ecological" => (15, "qualia:BiomassDensity", "canopy_wind_sway", "qualia:manifold:ecological", &["ScienceChemistryClinical"][..]),
191        "relativistic" => (16, "qualia:LorentzGamma", "black_hole_lensing", "qualia:manifold:relativistic", &["ScienceChemistryClinical", "MathCasAndSolvers"][..]),
192        "studio-bay" => (0, "qualia:Surface", "cyber_glass", "qualia:surface:studio-bay", &["StudioAndHypermedia", "ComputationalGeometry"][..]),
193        "research" => (1, "qualia:Surface", "wire_particles", "qualia:surface:research", &["StatisticsMlAndResearch", "ScienceChemistryClinical"][..]),
194        "media" => (2, "qualia:Surface", "aurora_curtains", "qualia:surface:media", &["StudioAndHypermedia"][..]),
195        "social" => (3, "qualia:Surface", "social_force_graph", "qualia:surface:social", &["EconomicsAndGovernance"][..]),
196        "communications" => (4, "qualia:Surface", "cyber_lattice", "qualia:surface:communications", &["StudioAndHypermedia"][..]),
197        "knowledge" => (5, "qualia:Surface", "barnes_hut_graph_physics", "qualia:surface:knowledge", &["LogicAndSemantics"][..]),
198        "ontology" => (6, "qualia:Surface", "deontic_halo", "qualia:surface:ontology", &["LogicAndSemantics"][..]),
199        "projects" => (7, "qualia:Surface", "flow_sankey", "qualia:surface:projects", &["EconomicsAndGovernance"][..]),
200        "rights" => (8, "qualia:Surface", "jural_correlator", "qualia:surface:rights", &["EconomicsAndGovernance", "LogicAndSemantics"][..]),
201        "sanctuary" => (9, "qualia:Surface", "aurora_curtains", "qualia:surface:sanctuary", &["EconomicsAndGovernance"][..]),
202        "health" => (10, "qualia:Surface", "bioluminescent_mycelium", "qualia:surface:health", &["ScienceChemistryClinical"][..]),
203        "anatomy" => (11, "qualia:Surface", "thermal_infrared", "qualia:surface:anatomy", &["ScienceChemistryClinical"][..]),
204        "studio" => (12, "qualia:Surface", "cyber_glass", "qualia:surface:studio", &["StudioAndHypermedia"][..]),
205        "datasets" => (13, "qualia:Surface", "manifold_grid_10d", "qualia:surface:datasets", &["StatisticsMlAndResearch"][..]),
206        "settings" => (14, "qualia:Surface", "cyber_glass", "qualia:surface:settings", &["StudioAndHypermedia"][..]),
207        "devices" => (15, "qualia:Surface", "silicon_die_thermal", "qualia:surface:devices", &["StudioAndHypermedia"][..]),
208        "vibe" => (16, "qualia:Surface", "cyber_glass", "qualia:surface:vibe", &["StudioAndHypermedia"][..]),
209        _ => (0, "qualia:Dimensionless", "aurora_curtains", "qualia:surface:generic", &["StudioAndHypermedia"][..]),
210    };
211
212    let tb_vals: Vec<Value> = toolboxes.iter().map(|s| Value::String((*s).into())).collect();
213    Ok(args::record([
214        ("op", Value::String("manifold_inspect".into())), ("id", Value::String(ids::POET_MANIFOLD_INSPECT.into())),
215        ("domain", Value::String(domain.into())), ("graph_iri", Value::String(graph_iri.into())),
216        ("axis_index", Value::U64(axis_index)), ("unit", Value::String(unit.into())),
217        ("default_shader", Value::String(default_shader.into())), ("default_toolboxes", Value::List(tb_vals)),
218        ("shell", Value::String("poet".into())),
219    ]))
220}
221
222/// `Poet.toolchain_execute` — executes toolchains, defines mind-map links, logs coop contributions, and settles commerce.
223pub fn toolchain_execute(args_v: &Value, span: Span) -> Result<Value, Diagnostic> {
224    let op = args::rec_str(args_v, "op").unwrap_or("execute");
225
226    if let Some(res) = super::os_shared_services::handle_shared_service(op, args_v, span) {
227        return res;
228    }
229
230    if let Some(res) = super::semantic_instrument_bridge::handle_semantic_instrument(op, args_v, span) {
231        return res;
232    }
233
234    if op == "connection_define" {
235        let (from, to, t_mf) = (args::rec_str(args_v, "from").unwrap_or("container-1"), args::rec_str(args_v, "to").unwrap_or("container-2"), args::rec_str(args_v, "target_manifold").unwrap_or(""));
236        let (rel_iri, l_mod, r_expr) = (args::rec_str(args_v, "relation_iri").unwrap_or("qualia:groundsObservation"), args::rec_str(args_v, "logic_modality").unwrap_or("Deontic"), args::rec_str(args_v, "rule_expr").unwrap_or("{ ?a qualia:linksTo ?b } => { ?b qualia:derived true }"));
237        let op_hex = match l_mod.to_ascii_lowercase().as_str() { "deontic" => "0x10", "epistemic" => "0x20", "paraconsistent" => "0x30", "ltl" => "0x40", _ => "0x01" };
238        let conn_id = format!("conn_{:016x}", crate::q_hash(&format!("{from}->{to}:{rel_iri}")));
239        let (did, clock, qcount) = save_art(&conn_id, "MindMapConnection", &format!("{from} -> {to}"), "connection_define", &[("from", from), ("to", to), ("target_manifold", t_mf), ("relation_iri", rel_iri), ("logic_modality", l_mod), ("rule_expr", r_expr), ("opcode_hex", op_hex)]);
240        return Ok(args::record([
241            ("status", Value::String("connected".into())), ("op", Value::String("connection_define".into())),
242            ("id", Value::String(ids::POET_TOOLCHAIN_EXECUTE.into())), ("connection_id", Value::String(conn_id)),
243            ("from", Value::String(from.into())), ("to", Value::String(to.into())),
244            ("target_manifold", Value::String(t_mf.into())), ("relation_iri", Value::String(rel_iri.into())),
245            ("logic_modality", Value::String(l_mod.into())), ("rule_expr", Value::String(r_expr.into())),
246            ("opcode_hex", Value::String(op_hex.into())), ("did_q42", Value::U64(did)),
247            ("lamport_clock", Value::U64(clock)), ("quin_count", Value::U64(qcount)), ("shell", Value::String("poet".into())),
248        ]));
249    }
250
251    if op == "coop_contribution_log" {
252        let (p_id, c_did) = (args::rec_str(args_v, "project_id").unwrap_or("proj-default"), args::rec_str(args_v, "contributor_did").unwrap_or("did:q42:local-self"));
253        let (eff_m, cap_c) = (args::rec_u64(args_v, "effort_minutes").unwrap_or(60), args::rec_u64(args_v, "capital_cents").unwrap_or(0));
254        let roi = args::rec_f64(args_v, "roi_multiplier").unwrap_or(1.25);
255        let (art_did, cont_id) = (args::rec_str(args_v, "artifact_did_q42").unwrap_or("did:q42:artifact"), args::rec_str(args_v, "container_id").unwrap_or("container-1"));
256        let summary = args::rec_str(args_v, "summary").unwrap_or("POET Shed artifact contribution");
257        let ob_units = (eff_m as f64 * 0.5 + (cap_c as f64 / 100.0)) * roi;
258        let c_id = format!("contrib_{:016x}", crate::q_hash(&format!("{p_id}:{c_did}:{summary}")));
259        let (did, clock, qcount) = save_art(&c_id, "CoopContribution", summary, "coop_contribution_log", &[("project_id", p_id), ("contributor_did", c_did), ("container_id", cont_id), ("obligation_units", &ob_units.to_string())]);
260        return Ok(args::record([
261            ("status", Value::String("logged".into())), ("op", Value::String("coop_contribution_log".into())),
262            ("id", Value::String(ids::POET_TOOLCHAIN_EXECUTE.into())), ("contribution_id", Value::String(c_id)),
263            ("project_id", Value::String(p_id.into())), ("contributor_did", Value::String(c_did.into())),
264            ("effort_minutes", Value::U64(eff_m)), ("capital_cents", Value::U64(cap_c)),
265            ("roi_multiplier", Value::F64(roi)), ("obligation_units", Value::F64(ob_units)),
266            ("artifact_did_q42", Value::String(art_did.into())), ("container_id", Value::String(cont_id.into())),
267            ("did_q42", Value::U64(did)), ("lamport_clock", Value::U64(clock)), ("quin_count", Value::U64(qcount)),
268            ("shell", Value::String("poet".into())),
269        ]));
270    }
271
272    if op == "wallet_multichain_status" || op == "commerce_settle" {
273        let (chain, cp_did) = (args::rec_str(args_v, "chain").unwrap_or("did:q42"), args::rec_str(args_v, "counterparty_did").unwrap_or("did:q42:commons-pool"));
274        let (amt, asset) = (args::rec_f64(args_v, "amount").unwrap_or(100.0), args::rec_str(args_v, "asset").unwrap_or("QCREDIT"));
275        let (p_id, memo) = (args::rec_str(args_v, "project_id").unwrap_or("proj-default"), args::rec_str(args_v, "memo").unwrap_or("Cooperative commerce settlement"));
276        let chains = "did:q42,bitcoin-taproot,solana,polkadot,cosmos-ibc,solid-rea-credit";
277        let tx_id = format!("tx_{:016x}", crate::q_hash(&format!("{chain}:{cp_did}:{memo}")));
278        let (did, clock, qcount) = save_art(&tx_id, "CommerceTx", memo, op, &[("chain", chain), ("counterparty_did", cp_did), ("amount", &amt.to_string()), ("asset", asset), ("project_id", p_id)]);
279        return Ok(args::record([
280            ("status", Value::String("settled".into())), ("op", Value::String(op.into())),
281            ("id", Value::String(ids::POET_TOOLCHAIN_EXECUTE.into())), ("tx_id", Value::String(tx_id)),
282            ("chain", Value::String(chain.into())), ("supported_chains", Value::String(chains.into())),
283            ("counterparty_did", Value::String(cp_did.into())), ("amount", Value::F64(amt)),
284            ("asset", Value::String(asset.into())), ("project_id", Value::String(p_id.into())),
285            ("did_q42", Value::U64(did)), ("lamport_clock", Value::U64(clock)), ("quin_count", Value::U64(qcount)),
286            ("shell", Value::String("poet".into())),
287        ]));
288    }
289
290    let chain = args::rec_str(args_v, "chain").or_else(|| args::rec_str(args_v, "pipeline")).or_else(|| args::rec_str(args_v, "tool")).ok_or_else(|| args::bad(span, "Poet.toolchain_execute needs chain"))?;
291    let target = args::rec_str(args_v, "target").unwrap_or("active_manifold");
292    let stages = args::rec_str_list(args_v, "stages").unwrap_or_else(|| vec!["ingest".into(), "validate_shacl".into(), "compile_wgsl".into(), "seal_q42".into()]);
293    let stage_vals: Vec<Value> = stages.iter().cloned().map(Value::String).collect();
294    let stages_joined = stages.join(" -> ");
295
296    let art_id = if target == "active_manifold" { "manifold:active".to_string() } else { target.to_string() };
297    let (did, clock, qcount) = save_art(&art_id, "Container", &art_id, &format!("toolchain:{chain}"), &[("last_toolchain", chain), ("last_stages", &stages_joined)]);
298
299    Ok(args::record([
300        ("op", Value::String("toolchain_execute".into())), ("id", Value::String(ids::POET_TOOLCHAIN_EXECUTE.into())),
301        ("chain", Value::String(chain.into())), ("target", Value::String(target.into())),
302        ("stage_count", Value::U64(stage_vals.len() as u64)), ("stages", Value::List(stage_vals)),
303        ("status", Value::String("completed".into())), ("did_q42", Value::U64(did)),
304        ("lamport_clock", Value::U64(clock)), ("quin_count", Value::U64(qcount)),
305        ("shell", Value::String("poet".into())),
306    ]))
307}
308
309#[cfg(test)]
310mod tests {
311    use super::*;
312    use std::collections::BTreeMap;
313
314    fn rec(pairs: &[(&str, Value)]) -> Value {
315        let mut m = BTreeMap::new();
316        for (k, v) in pairs { m.insert((*k).into(), v.clone()); }
317        Value::Record(m)
318    }
319
320    #[test]
321    fn test_shed_toolchest_and_constructs() {
322        let span = Span { start: 0, end: 0 };
323        let Value::Record(tc) = toolchest_list(&rec(&[("family", Value::String("Applications".into()))]), span).unwrap() else { panic!("rec"); };
324        assert_eq!(tc.get("family_count"), Some(&Value::U64(1)));
325        assert_eq!(tc.get("construct_count"), Some(&Value::U64(10)));
326        assert_eq!(tc.get("shed_toolbox_count"), Some(&Value::U64(8)));
327        assert!(tc.contains_key("recommended_toolbox"));
328    }
329
330    #[test]
331    fn test_toolbox_and_toolchain_creation() {
332        let span = Span { start: 0, end: 0 };
333        let Value::Record(tbox) = toolchest_list(&rec(&[
334            ("op", Value::String("toolbox_create".into())),
335            ("toolbox_id", Value::String("geo-solvers".into())),
336            ("label", Value::String("Geometry Solvers".into())),
337        ]), span).unwrap() else { panic!("rec"); };
338        assert_eq!(tbox.get("status"), Some(&Value::String("created".into())));
339
340        let Value::Record(tchain) = toolchest_list(&rec(&[
341            ("op", Value::String("toolchain_create".into())),
342            ("toolchain_id", Value::String("mesh-opt".into())),
343        ]), span).unwrap() else { panic!("rec"); };
344        assert_eq!(tchain.get("status"), Some(&Value::String("created".into())));
345    }
346
347    #[test]
348    fn test_manifold_inspect_dimensional_and_workspace() {
349        let span = Span { start: 0, end: 0 };
350        let Value::Record(mi_dim) = manifold_inspect(&rec(&[("domain", Value::String("Ecological".into()))]), span).unwrap() else { panic!("rec"); };
351        assert_eq!(mi_dim.get("axis_index"), Some(&Value::U64(15)));
352
353        let Value::Record(mi_ws) = manifold_inspect(&rec(&[("domain", Value::String("studio-bay".into()))]), span).unwrap() else { panic!("rec"); };
354        assert_eq!(mi_ws.get("graph_iri"), Some(&Value::String("qualia:surface:studio-bay".into())));
355    }
356
357    #[test]
358    fn test_toolchain_extensions() {
359        let span = Span { start: 0, end: 0 };
360        let Value::Record(conn) = toolchain_execute(&rec(&[
361            ("op", Value::String("connection_define".into())),
362            ("from", Value::String("cad-container".into())),
363            ("to", Value::String("fem-analysis".into())),
364        ]), span).unwrap() else { panic!("rec"); };
365        assert_eq!(conn.get("status"), Some(&Value::String("connected".into())));
366        assert_eq!(conn.get("opcode_hex"), Some(&Value::String("0x10".into())));
367
368        let Value::Record(coop) = toolchain_execute(&rec(&[
369            ("op", Value::String("coop_contribution_log".into())),
370            ("project_id", Value::String("qualia-shed".into())),
371            ("effort_minutes", Value::U64(120)),
372        ]), span).unwrap() else { panic!("rec"); };
373        assert_eq!(coop.get("status"), Some(&Value::String("logged".into())));
374
375        let Value::Record(comm) = toolchain_execute(&rec(&[
376            ("op", Value::String("commerce_settle".into())),
377            ("amount", Value::F64(250.0)),
378        ]), span).unwrap() else { panic!("rec"); };
379        assert_eq!(comm.get("status"), Some(&Value::String("settled".into())));
380
381        let Value::Record(os_apps) = toolchain_execute(&rec(&[
382            ("op", Value::String("os_apps_manifest".into())),
383        ]), span).unwrap() else { panic!("rec"); };
384        assert_eq!(os_apps.get("op"), Some(&Value::String("os_apps_manifest".into())));
385        assert_eq!(os_apps.get("app_count"), Some(&Value::U64(7)));
386
387        let Value::Record(si_cat) = toolchain_execute(&rec(&[
388            ("op", Value::String("si_catalog".into())),
389        ]), span).unwrap() else { panic!("rec"); };
390        assert_eq!(si_cat.get("op"), Some(&Value::String("instrument_catalog".into())));
391        assert_eq!(si_cat.get("demo_count"), Some(&Value::U64(6)));
392    }
393}