1use super::args;
9use super::ids;
10use vibe::{Diagnostic, Span, Value};
11
12pub 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
34pub 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
69pub 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
98pub 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
170pub 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
222pub 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}