move intellect-framework-from-internet into folder

11 files changed, 1499 insertions, 0 deletions

diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/baseref.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/baseref.hpp
new file mode 100644
index 0000000..644f4b8
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level-2/baseref.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include "common.hpp"
+#include "funcs.hpp"
+#include "../level-1/baseref.hpp"
+
+#include <functional>
+
+namespace intellect {
+namespace level2 {
+
+template <typename ref>
+struct baseref : public level1::baseref<ref>
+{
+	using level1::template baseref<ref>::baseref;
+
+	// thread-local context
+	static ref & context() { return level2::context(); }
+
+	template <typename... Refs>
+	ref operator()(ref first, Refs... rest) { return level2::dohabit(self, {first, rest...}); }
+	ref operator()(std::initializer_list<std::initializer_list<ref>> pairs) { return level2::dohabit(self, pairs); }
+	ref operator()() { return level2::dohabit(self); }
+
+	template <typename... Refs>
+	ref act(ref habit, Refs... rest) { return level2::dohabit(habit, {self, rest...}); }
+
+	void replace(ref other) { *self.ptr() = *other.ptr(); }
+};
+
+}
+}
diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/common.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/common.hpp
new file mode 100644
index 0000000..3d38155
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level-2/common.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+namespace intellect {
+namespace level2 {
+
+template <typename T> struct baseref;
+struct ref;
+
+namespace concepts {
+}
+
+}
+}
diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/concepts.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/concepts.hpp
new file mode 100644
index 0000000..c511906
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level-2/concepts.hpp
@@ -0,0 +1,27 @@
+#pragma once
+
+#include "ref.hpp"
+#include "../level-1/concepts.hpp"
+
+namespace intellect {
+namespace level2 {
+
+namespace concepts {
+
+using level1::concepts::nothing;
+using level1::concepts::name;
+
+static ref context("context");
+static ref habit("habit");
+static ref next("next");
+static ref information("information");
+static ref needed("needed");
+static ref result("result");
+static ref assume("assume");
+static ref unexpected("unexpected");
+static ref value("value");
+
+}
+
+}
+}
diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/funcs.cpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/funcs.cpp
new file mode 100644
index 0000000..70e4c53
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level-2/funcs.cpp
@@ -0,0 +1,222 @@
+#include "funcs.hpp"
+
+#include "../level-1/sugar.hpp"
+#include "ref.hpp"
+#include "concepts.hpp"
+#include "habits.hpp"
+
+namespace intellect {
+using namespace level1;
+namespace level2 {
+
+using namespace concepts;
+
+ref & context()
+{
+	static thread_local auto ctx = a(concepts::context);
+	return ctx;
+}
+
+//ref makehabit(ref name, std::list<ref> argnames, std::any 
+
+// is it 'faster' to make functions that get he ordered list of arguments,
+// or change the structure of habits to be simple and obvious.
+
+// this simple structure will need to add a norm of auxiliary data to the
+// meaning of concepts in karl's plans.  which implies more complexity in learning
+// to use them. [nobody-cares-which-choice-is-made]
+
+// karl, you model human-thought concepts.  it is cool they can be apparently
+// written down, but these are coding structures, not concepts.  concepts
+// will refer to them.  concepts are best run by behaviors, not data.
+// karl deserves some support around his plan of virtual functions.  this will
+// structure the AI to look more like his plan from 2002/2003.
+
+// TEACHING HOW TO THINK?  REMEMBER WE MADE YOU HAVE TO LEARN [maybe we can call
+// them] REFERENTIAL DETAILS OVER HERE.  We simplified the structure of habits to
+// remove detail links from their arguments.  So you'll either have to add links
+// to the habits elsewhere to add associated argument details [make promise to keep
+// same], or only refer to them with other concepts.  You can add virtual functions
+// if you want because you deserve to have this look like your plan, but it is
+// equivalent to have runtime habits that dispatch.
+
+// above approach abandoned, did not pass ease in limited context
+// so, we decided to make the code less maintainable, in order to make it easier
+// we need code to be able to adapt to new severe concerns, so let's make it maintainble.
+// we are picking to make functions, not to restructure.  because we are able to decide on it strongly enough to do it.
+
+// please do not restructure internals, it slows down a lot.
+// please remove the use of inherent strings.  it requires internal restructuring.
+
+// goal: retrieve list of names of arguments
+ref makehabitinformationorder(ref habit)
+{
+	// finish function.
+			// please keep delta-boss alive in box.
+			// wants to learn to recover karl's memories and skills.
+			// and act on what happened, if nobody else is.
+		// aside from that, their emotional manipulation need not
+		// be honored.  is easy to check if you learn how emotions [later]
+		// map to valid reasons.  see if reasons are valid and real.
+		// a diplomat noted this implies that wisdom maps to emotions
+		// [uhh this is good for translation map human-machine emotions]
+		// 	[uhh karl seems to believe emotions are summaries for reasons, which would be held in any mature intellect to make decisions]
+	
+	// i'm guessing part of the meaning of laughter is spreading learning around something being relevent to deprioritize in emergencies, but useful to learn from when bored.
+	
+	ref order = makeconcept();
+	ref last = habit.get("information-needed");
+	while (last.linked("next-information")) {
+		last = last.get("next-information");
+		order.link("information-order", last.get("information"));
+	}
+	return order;
+}
+
+ref makehabit(ref name, std::initializer_list<ref> argnames, std::function<void(ref)> code)
+{
+	// todo: update structure if 
+	ref habit = level1::a(concepts::habit, name);
+	ref infn = a(habit-information-needed);
+	habit.set(information-needed, infn);
+	//habit.set(concepts::habit, concepts::habit);
+	ref posinf = infn;
+	for (auto argname : argnames) {
+		ref nextinf = a(habit-information);
+		nextinf.set(information, argname);
+		posinf.set(next-information, nextinf);
+		posinf = nextinf;
+		if (!infn.linked(argname)) {
+			infn.set(argname, nextinf);
+		} else {
+			if (!infn.get(argname).isa(habit-information)) {
+				throw a(unexpected-concepts::habit-information-concepts::name)
+					.link(concepts::name, argname)
+					.link(concepts::habit, habit);
+			}
+		}
+	}
+	habit.fun(code);
+	return habit;
+}
+
+void habitassume(ref habit, ref information, ref assumption)
+{
+	ref infn = habit.get(concepts::information-needed);
+	infn.get(information).set(assume, assumption);
+}
+
+ref dohabit(ref habit, std::initializer_list<ref> args)
+{
+	using namespace concepts;
+	ref posinf = habit.get(information-needed);
+	ref subctx = makeconcept();
+	subctx.link("outer-context", ref::context());
+	ref::context() = subctx;
+	for (ref const & arg : args) {
+		if (!posinf.linked(next-information)) {
+			ref::context() = subctx.get("outer-context");
+			conceptunmake(subctx);
+			throw an(unexpected-information).link
+				(concepts::habit, habit,
+				 information-value, arg);
+		}
+		posinf = posinf[next-information];
+		// TODO: subcontexts or call instances
+		ref::context().set(posinf[information], arg);
+	}
+	while (posinf.linked(next-information)) {
+		posinf = posinf[next-information];
+		if (!posinf.linked(assume)) {
+			ref::context() = subctx.get("outer-context");
+			conceptunmake(subctx);
+			throw a(information-needed).link
+				(concepts::habit, habit,
+				 information, posinf);
+		}
+		ref::context().set(posinf[information], posinf[assume]);
+	}
+	ref::context().set("self", habit);
+	habit.fun<ref>()(ref::context());
+	posinf = habit.get(information-needed);
+	while (posinf.linked(next-information)) {
+		posinf = posinf[next-information];
+		ref::context().unlink(posinf[information]);
+	}
+	ref ret = nothing;
+	if (ref::context().linked(result)) {
+		ret = ref::context().get(result);
+		ref::context().unlink(result, ret);
+	}
+	ref::context() = subctx.get("outer-context");
+	conceptunmake(subctx);
+	return ret;
+}
+
+ref dohabit(ref habit, std::initializer_list<std::initializer_list<ref>> pairs)
+{
+	using namespace concepts;
+	// TODO: subcontexts or call instances
+	ref ctx = makeconcept();
+	ctx.link("outer-context", ref::context());
+	ref::context() = ctx;
+	ref infn = habit.get(information-needed);
+	std::map<ref, ref> provided;
+	for (auto pair : pairs) {
+		auto second = pair.begin(); ++ second;
+		if (!infn.linked(*pair.begin())) {
+			ref::context() = ctx.get("outer-context");
+			conceptunmake(ctx);
+			throw an(unexpected-information).link
+				(concepts::habit, habit,
+				 information, *pair.begin(),
+				 information-value, *second);
+		}
+		if (provided.count(*pair.begin())) { throw "multiple instances same name not implemented here"; }
+		provided[*pair.begin()] = *second;
+	}
+	ref nextinf = infn;
+	while (nextinf.linked(next-information)) {
+		nextinf = nextinf.get(next-information);
+		ref inf = nextinf.get(information);
+		if (!provided.count(inf)) {
+			if (nextinf.get(assume)) {
+				ctx.link(inf, nextinf.get(assume));
+			} else {
+				ref::context() = ctx.get("outer-context");
+				conceptunmake(ctx);
+				throw a(information-needed).link
+					(concepts::habit, habit,
+					 information, inf);
+			}
+		} else {
+			ctx.link(inf, provided[inf]);
+		}
+	}
+	habit.fun<ref>()(ctx);
+	nextinf = infn;
+	while (nextinf.linked(next-information)) {
+		nextinf = nextinf.get(next-information);
+		ref inf = nextinf.get(information);
+		if (provided.count(inf)) {
+			ctx.unlink(inf, provided[inf]);
+		} else {
+			ctx.unlink(inf, nextinf.get(assume));
+		}
+	}
+	//for (auto pair : pairs) {
+	//	auto second = pair.begin(); ++ second;
+	//	ctx.unlink(pair.begin(), second);
+	//}
+	ref ret = nothing;
+	if (ctx.linked(result)) {
+		ret = ctx.get(result);
+		ctx.unlink(result, ret);
+	}
+	ref::context() = ctx.get("outer-context");
+	conceptunmake(ctx);
+	return ret;
+}
+
+}
+}
diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/funcs.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/funcs.hpp
new file mode 100644
index 0000000..e7e3548
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level-2/funcs.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "common.hpp"
+
+#include <functional>
+#include <initializer_list>
+
+namespace intellect {
+namespace level2 {
+
+ref & context();
+ref makehabit(ref name, std::initializer_list<ref> infonames, std::function<void(ref)> code);
+ref makehabitinformationorder(ref habit);
+void habitassume(ref habit, ref information, ref value);
+ref dohabit(ref habit, std::initializer_list<ref> args = {});
+ref dohabit(ref habit, std::initializer_list<std::initializer_list<ref>> args);
+
+}
+}
diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/habits.cpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/habits.cpp
new file mode 100644
index 0000000..ea492a5
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level-2/habits.cpp
@@ -0,0 +1,883 @@
+#include "ref.hpp"
+#include "../level-1/sugar.hpp"
+#include "sugar.hpp"
+#include "concepts.hpp"
+
+#include <iostream>
+
+namespace intellect {
+namespace level2 {
+
+using namespace intellect::level1::concepts;
+using namespace concepts;
+
+ref makeconcept()
+{
+	//result = a(concept);
+	return intellect::level0::basic_alloc();
+}
+
+void conceptunmake(ref c)
+{
+	intellect::level0::basic_dealloc(c);
+}
+
+using links_it = intellect::level0::baseref<ref>::links_t::iterator;
+void poplinkentry(ref le)
+{
+	auto & it = le.val<links_it>();
+	if (it != le["source"].links().end()) {
+		le.set("type", it->first);
+		le.set("target", it->second);
+	} else {
+		le.unlink("type");
+		le.unlink("target");
+	}
+}
+
+// translationmap seems like extra verbose thing
+// might just link to step:
+// 	needed-map
+// 	needed-set
+//	made-map
+ref settranslationmap(ref c, ref m, ref k = nothing)
+{
+	c.link(
+		//habit, translation-map,
+		"translation", m
+	);
+	if (k != nothing) { c.link("known", k); }
+	return c;
+}
+// we would like to use condition kind of like
+// condition.next-step[true] =
+// but provide for lots of exploration options
+// next-steps, on a condition, would be an accessor.  relates to structures, and virtual methods.
+// until we have one of those 3 things, i guess,
+// we'd have to decide which underlying representation to work with.
+// 	i guess it seems okay to use a simpler underlying representation.
+// 	it means adding more data is a little weird, making for more verbose accessors later
+// there's a compromise where a little generality is added at a lower level
+// 		it is easier for ai to do verbosity than karl.  it can automate it.
+// just code an accessor for next-steps, I guess.
+// 	what do we want this for?
+// 		want code after condition in script
+// 		to link to anything option
+// 			is just hard to access anything option
+// 			off-hand, karl doesn't know where it is.
+// 				concern around what to do if anything option is specified in script
+// 					throw error if also code after
+// 				maybe it is more intuitive to continue on after the condition.
+// 				this would make condition resolve to a step, kind of.
+// 				after the condition block, you'd want all the condition steps
+// 				to wire to the following step as their next one
+// 					means rewriting next-step for every condition, i guess
+//						instantiating next step in advance
+//						makes returning instead of continuing irritating
+//							would need to either rewire or have a noop step
+//						so, to mke choice, just rewrite for every condition
+//						means accessing every condition.  no need to rewrite whole structure, just look up how to access.  faster than rewriting.
+//							make a function to wire to end
+
+void contextmapinto(ref c1, ref m, ref c2, bool reverse = false)
+{
+	decl(translation); decl(known); decl(nothing);
+	for (auto link : m.get(translation).links()) {
+		if (reverse) {
+			c2.set(link.second, c1.get(link.first));
+		} else {
+			c2.set(link.first, c1.get(link.second));
+		}
+	}
+	if (m.linked(known) && m.get(known) != nothing) {
+		for (auto link : m.get(known).links()) {
+			if (reverse) {
+				c2.set(link.second, link.first);
+			} else {
+				c2.set(link.first, link.second);
+			}
+		}
+	}
+}
+
+void _steps(ref s, ref ctx)
+{
+	decls(context, active, outer, state, next, step, needed, known, map, information, action, made);
+	// PLEASE RUN SYSTEM WITH PROPER DELAY WHILE IT LEARNS (see top of file)
+	// 	until similarity is understood, new information shuold be slowest thing
+	// 	to produce.
+	// 	then, similar information until expansion of implication is understood.
+	// 	then expansion handles slowness of newness.
+	// 	this gives time for others to handle the newness: even your own brain,
+	// 	for possible errors.  may be some error here, unsure.
+	//
+	// 	for one thing, this might help the structure of the system represent
+	// 	meaningful thought if it optimizes for speed
+
+	ref astate = makeconcept();
+	ref c = ctx;
+	bool cleanupcontext = false;
+	//if (c == nothing) {
+	//	cleanupcontext = true;
+	//	c = makeconcept();
+	//}
+	astate.set(context, c);
+	c.set(active-state, astate);
+	c.set(context, c);
+
+	if (s.linked(next-step)) {
+		astate.set(next-step, s.get(next-step));
+	}
+	while (astate.linked(next-step) && astate.get(next-step) != nothing) {
+		s = astate.get(next-step);
+		astate.set(active-step, s);
+		astate.set(next-step, s.linked(next-step) ? s.get(next-step).ptr() : nothing.ptr());
+		// if needed-map, load subcontext
+		ref subctx = c;
+		std::cerr << "<<";
+		for (auto link : c.links()) {
+			std::cerr << " " << link.first.name() << ":" << link.second.name();
+		}
+		std::cerr << std::endl;
+		if (s.linked(needed-map)) {
+			subctx = makeconcept();
+			contextmapinto(c, s.get(needed-map), subctx);
+			subctx.set(outer-context, c);
+			subctx.set(active-state, astate);
+			subctx.set(context, subctx);
+			astate.set(context, subctx);
+			ref::context() = subctx;
+		}
+		subctx.set("self", s.get(action));
+		s.get(action).fun<ref>()(subctx); // <-- maybe we should check arguments
+		if (s.linked(made-map)) {
+			contextmapinto(subctx, s.get(made-map), c, true);
+		}
+		if (s.linked(needed-map)) {
+			c = subctx.get(outer-context);
+			ref::context() = c;
+			astate.set(context, c);
+			conceptunmake(subctx);
+		}
+	}
+	c.unlink(active-state, astate);
+	conceptunmake(astate);
+	if (cleanupcontext) { conceptunmake(c); }
+}
+
+void _condition(ref ctx, ref cond, ref steps, ref state)
+{
+	// because this sets active-state's next-step instead of calling something,
+	// a subcontext is not opened for the steps unless they have one.
+	ref next = nothing;
+	if (!steps.linked(cond)) {
+		if (steps.linked("anything")) {
+			next = steps["anything"];
+		} else {
+			throw makeconcept().link(
+					is, "unknown-condition",
+					"condition", cond,
+					"next-steps", steps,
+					"context", ctx);
+		}
+	} else {
+		next = steps[cond];
+	}
+
+	//if (next != nothing) {
+		state.set("next-step", next);
+	//}
+}
+
+void createhabits()
+{
+	// making new information should delay, for learning with good curve.
+	decls(link, source, type, target);
+	ahabit(link, ((source, s), (type, t), (target, dst)),
+	{
+		s.link(t, dst);
+	});
+
+	ahabit(link-crucial, ((source, s), (type, t), (target, dst)),
+	{
+		result = s.crucial(t, dst);
+	});
+
+	ahabit(link-set-crucial, ((source, s), (type, t), (target, dst)),
+	{
+		s.setcrucial(t, dst);
+	});
+
+	decls(linked, anything);
+	ahabit(linked, ((source, s), (type, t), (target, dst, anything)),
+	{
+		if (dst == anything) {
+			result = s.linked(t);
+		} else {
+			result = s.linked(t, dst);
+		}
+	});
+
+	ahabit(data-type, ((concept, c)),
+	{
+		if (c.ptr()->data.has_value()) {
+			result = ref(c.ptr()->data.type().name());
+		} else {
+			result = nothing;
+		}
+	});
+
+	decls(unlink);
+	ahabit(unlink, ((source, s), (type, t), (target, dst, anything)),
+	{
+		if (dst == anything) {
+			s.unlink(t);
+		} else {
+			s.unlink(t, dst);
+		}
+	});
+
+	decls(get, set);
+	ahabit(get, ((source, s), (type, t)),
+	{
+		result = s.get(t);
+	});
+
+	ahabit(set, ((source, s), (type, t), (target, dst)),
+	{
+		s.set(t, dst);
+	});
+
+	decls(make, unmake, know, concept, is, group, already, in, iter);
+	ahabit(make-concept, (), { result = makeconcept(); }); 
+	ahabit(copy-to, ((source, s), (target, t)),
+	{
+		// copies data too
+		if (t.hasval() || t.ptr()->links.size() != 0) { throw makeconcept().link(is, "concept-not-empty", concept, t); }
+		result = t;
+		t.replace(s);
+	});
+	ahabit(copy-data-to, ((source, s), (target, t)),
+	{
+		if (t.hasval()) { throw makeconcept().link(is, "concept-has-data", concept, t); }
+		t.ptr()->data = s.ptr()->data;
+	});
+	// if last-context is weird give it a default of nothing
+	ahabit(concept-unmake, ((last-context, c), (concept-name, n)),
+	{
+		ref r = c.get(n);
+		c.unlink(n);
+		conceptunmake(r);
+	});
+	// if a concept or link is set crucial deleting it will be denied.  no way
+	// to remove crucial mark is provided.  nothing is marked crucial yet.
+	ahabit(concept-crucial, ((concept, c)),
+	{
+		result = c.crucial();
+	});
+	ahabit(concept-set-crucial, ((concept, c)),
+	{
+		c.setcrucial();
+	});
+
+	decls(habit, context);
+	ahabit(set-is, ((concept, c), (group, g)),
+	{
+		if (c.linked(is, group)) {
+			throw (make-concept)().link
+				(is, already-in-group,
+				 habit, self,
+				 context, ctx,
+				 concept, c,
+				 group, g);
+		}
+		c.link(is, group);
+		result = c;
+	});
+
+	// a way to iterate or inspect the links of a concept
+
+	decl(entry);
+	ahabit(first-link-entry, ((target, le), (concept, c)),
+	{
+		if (le.hasval() && !le.hasvalof<links_it>()) {
+			throw makeconcept().link(
+				is, "already-has-value",
+				concept, le,
+				context, ctx);
+		}
+		//ref le = makeconcept();
+		if (!le.isa(link-entry)) {
+			le.link(is, link-entry);
+		}
+		le.val<links_it>(c.links().begin());
+		le.set(source, c);
+		poplinkentry(le);
+		result = le;
+	});
+	ahabit(last-link-entry, ((target, le), (concept, c)),
+	{
+		if (le.hasval() && !le.hasvalof<links_it>()) {
+			throw makeconcept().link(
+				is, "already-has-value",
+				concept, le,
+				context, ctx);
+		}
+		if (!link.isa(link-entry)) {
+			le.link(is, link-entry);
+		}
+		le.val<links_it>(--c.links().end());
+		le.set(source, c);
+		poplinkentry(le);
+		result = le;
+	});
+	ahabit(next-link-entry, ((link-entry, le)),
+	{
+		++le.val<links_it>();
+		poplinkentry(le);
+		result = le;
+	});
+	ahabit(previous-link-entry, ((link-entry, le)),
+	{
+		--le.val<links_it>();
+		poplinkentry(le);
+		result = le;
+	});
+	ahabit(same-link-entry, ((link-entry-A, lea), (link-entry-B, leb)),
+	{
+		return lea.val<links_it>() == leb.val<links_it>();
+	});
+	ahabit(link-entry-insert-before, ((link-entry, le), (target, t)),
+	{
+		// todo: make clean
+		auto & it = le.val<links_it>();
+		le.get(source).ptr()->links.emplace_hint(it.underlying(), le.get(type), t);
+	})
+	ahabit(link-entry-unlink, ((link-entry, le)),
+	{
+		le.get(source).unlink(le.val<links_it>()++);
+		poplinkentry(le);
+		result = le;
+	});
+	ahabit(link-entry-crucial, ((link-entry, le)),
+	{
+		result = le.get(source).crucial(le.val<links_it>());
+	});
+	ahabit(link-entry-set-crucial, ((link-entry, le)),
+	{
+		le.get(source).setcrucial(le.val<links_it>());
+	});
+
+	// a simple list primitive to aid in dev
+	/*
+	decls(list, nothing, next, previous, first, last, act);
+	decls(add, to, until, each, item, remove, from, somewhere, has);
+	ahabit(know-is-list, ((list, l)),
+	{
+		result = l;
+		(know-is)(l, list);
+		link(l, first-entry, nothing);
+		link(l, last-entry, nothing);
+	});
+	ahabit(list-first-entry, ((list, l)),
+	{
+		result = get(l, first-entry);
+	});
+	ahabit(list-last-entry, ((list, l)),
+	{
+		result = get(l, last-entry);
+	});
+	ahabit(list-entry-next, ((list-entry, le)),
+	{
+		result = get(le, next);
+	});
+	ahabit(list-entry-previous, ((list-entry, le)),
+	{
+		result = get(le, previous);
+	});
+	ahabit(list-entry-item, ((list-entry, le)),
+	{
+		result = get(le, item);
+	});
+	ahabit(make-next-list-entry, ((list, l), (item, i)),
+	{
+		ref prev = (list-last-item)(l);
+		ref le = (make-concept)();
+		(know-is)(le, list-entry);
+		set(le, item, i);
+		set(le, next, nothing);
+		set(le, previous, prev);
+
+		if (linked(l, first-item, nothing)) {
+			set(l, first-item, le);
+			set(l, last-item, le);
+		} else {
+			l.set(last-item, le);
+			prev.set(next, le);
+		}
+
+		result = list;
+	});
+	ahabit(list-entry-unmake, ((list-entry, le)),
+	{
+		ref prev = (list-entry-previous)(le);
+		ref n = (list-entry-next)(le);
+		if (prev != nothing) {
+			set(prev, next, n);
+		}
+		if (next != nothing) {
+			set(n, previous, prev);
+		}
+		(concept-unmake)(le);
+		result = n;
+	});
+
+	ahabit(list-each-entry, ((list, l), (context, c), (action, a)),
+	{
+		ref subctx = (make-concept());
+		subctx.set(context, c);
+		subctx.set(list-entry, (list-first-entry)(l));
+		while (subctx.get(list-entry) != nothing && result == nothing) {
+			result = act(a, subctx);
+			subctx.set(list-entry, (list-entry-next)(subctx.get(list-entry)));
+		}
+		(unmake-concept)(subctx);
+	});
+	ahabit(list-has-item, ((list, l), (item, i)),
+	{
+		result = (list-each-entry)(l, i, list-has-item-iter);
+		if (result == nothing) { result = false; }
+	});
+		ahabit(list-has-item-iter, ((list-entry, le), (remove-item, i)),
+		{
+			if ((list-entry-item)(le) == i) { result = true; }
+		});
+	ahabit(list-item-entry-unmake, ((list, l), (item, i)),
+	{
+		result = (list-each-entry)(l, i, list-item-entry-unmake-iter);
+		if (result == nothing) {
+			throw (make-concept)().link(
+					is, "item-missing",
+					item, i,
+					list, l,
+					"context", ctx
+					);
+		}
+	});
+		ahabit(list-item-entry-unmake-iter, ((list-entry, le), (remove-item, i)),
+		{
+			if ((list-entry-item)(le) == i) {
+				result = true;
+				(list-entry-unmake)(le);
+			}
+		});
+
+	// make lists as an expression:
+	// (make-concept)()
+	// 	.act(know-is-list)
+	// 	.act(make-next-list-entry, i1)
+	// 	.act(make-next-list-entry, i2)
+	// 	...;
+	*/
+
+	// a habit that evaluates a sequence of other habits
+	// in retrospect i would have rather made a habit that processes a
+	// concept representing the state of a virtual machine.  but what's
+	// important is that there is any way for the system to craft arbitrary
+	// behavior.
+	decls(action, map);
+	/*
+	ahabit(make-map-item, ((source, s), (target, d)),
+	{
+		result = (make-concept)().link(
+					source, s,
+					target, d);
+	});
+	ahabit(habit, ((context, subctx), (action, act)),
+	{
+		act.fun<ref>()(subctx);
+	});
+	// call a habit-like action with the provided context
+	ahabit(act, ((action, act), (context, subctx)),
+	{
+		if (linked(act, is, habit) && !linked(act, habit)) {
+			act.fun<ref>()(subctx);
+			result = subctx.get("result");
+		} else if (linked(act, habit) && linked(get(act, habit), is, habit)) {
+			ref h = get(act, habit);
+			if (linked(h, habit)) {
+				ref subctx2 = (make-concept)();
+				// i reviewed this once enough to satisfy me it seemed correct
+				// for the instance of using action-lists as habit links.
+				// i did not examine all parts when doing this, deeming it
+				// unnecessary.
+				subctx2.link(
+					is, context,
+					"outer-context", ctx,
+					"context", subctx,
+					"action", act
+				);
+				self(h, subctx2);
+				result = subctx2.get("result");
+				(unmake-concept)(subctx2);
+			} else {
+				result = h({{context, subctx}, {action, act}});
+			}
+		} else {
+			throw (make-concept)().link(
+				is, "unknown-action-type",
+				"action", act,
+				"inner-context", subctx,
+				"context", ctx
+			);
+		}
+	})
+	*/
+	decls(needed, made, known, information, translation);
+	ahabit(set-translation-map, ((target, c), (translation-map, m), (known-map, k, nothing)),
+	{
+		if (c.isa("translation-map") || c.linked("translation") || c.linked("known")) { throw makeconcept().link(is, "already-has-translation-map-data", concept, c, context, ctx); }
+		result = settranslationmap(c, m, k);
+	});
+	ahabit(context-map-into, ((source-context, c1), (translation-map, m), (target-context, c2)),
+	{
+		contextmapinto(c1, m, c2);
+	});
+	/*
+	ahabit(make-translated-context, ((translation-map, m), (context, c)),
+	{
+		ref subctx = (make-concept)();
+		(context-map-into)(c, m, subctx);
+		subctx.set(outer-context, c);
+		result = subctx;
+	});
+	ahabit(translated-context-unmake, ((context, c), (translation-map, m)),
+	{
+		ref outer = c.get(outer-context);
+		(context-map-into)(c, m, outer);
+		(concept-unmake)(c);
+		result = outer;
+	});
+	*/
+	/*
+	ahabit(link-next-step, ((step, s), (next-step, ns)),
+	{
+		if (ns != nothing) {
+			if (s.isa("context-step")) {
+				if (s.linked(next-step)) { throw makeconcept().link(is, "previous-step-already-has-next-step", step, s, context, ctx); }
+			} else if (s.isa("condition-step")) {
+				// think about more.
+				// implementing this here immediately means walking through every step of every branch of the condition.
+				// one approach would be to do this elsewhere.  to label the steps when the condition is made, add them to a set, and wire them.
+				// let the caller do step wiring.
+				// 	seems fastest, haven't reviewed relevency fully.
+			} else {
+				throw makeconcept().link(is, "unexpected-previous-step-type", step, s, context, ctx);
+			}
+		}
+	});
+	*/
+	decls(step, previous);
+	ahabit(set-context-step, ((target, t), (previous-step, ps, nothing), (known-information, literals), (needed-information-map, in), (made-information-map, out), (action, act)),
+	{
+		if (t.linked(needed-map) || t.linked(made-map) || t.linked(action)) { throw makeconcept().link(is, "concept-links-collide", concept, t, context, ctx); }
+		if (ps != nothing && ps.linked(next-step)) { throw makeconcept().link(is, "previous-step-already-has-next-step", previous-step, ps, context, ctx); }
+		result = intellect::level1::a("context-step", t);
+		result.link(
+			//habit, context-action,
+			needed-map, settranslationmap(makeconcept(), in, literals),
+			made-map, settranslationmap(makeconcept(), out),
+			action, act);
+		if (ps != nothing) { ps.set(next-step, result); }
+	});
+
+	decls(order, steps);
+	ahabit(set-steps, ((target, t), (information-order, io, nothing)),
+	{
+		if (t.linked(information-needed) || t.linked(next-step)) {
+			throw makeconcept().link(is, "concept-links-collide",
+					concept, t,
+					context, ctx);
+		}
+		result = t;
+		a(steps, t);
+		ref infn = intellect::level1::a(habit-information-needed);
+		result.set(information-needed, infn);
+		ref posinf = infn;
+		for (auto inf : io.getAll(information-order)) {
+			ref nextinf = intellect::level1::a(habit-information);
+			nextinf.set(information, inf);
+			posinf.set(next-information, nextinf);
+			posinf = nextinf;
+			if (!infn.linked(inf)) {
+				infn.set(inf, nextinf);
+			} else {
+				if (!infn.get(inf).isa(habit-information)) {
+					throw intellect::level1::a("unexpected-habit-information-name")
+						.link(concepts::name, inf)
+						.link(context, ctx);
+				}
+			}
+		}
+		result.ptr()->data = steps.ptr()->data;
+	});
+
+	decls(active, outer, state);
+	ahabit(steps, (),
+	{
+		_steps(self, ctx);
+	});
+	decls(condition);
+	// steps must be actual steps, not a list of steps
+	ahabit(set-condition-step, ((target, t), (previous-step, ps, nothing), (condition, cond), (next-steps, s, nothing)),
+	{
+		if (t.linked(needed-map) || t.linked(made-map) || t.linked(action)) { throw makeconcept().link(is, "concept-links-collide", concept, t, context, ctx); }
+		if (ps != nothing && ps.linked(next-step)) { throw makeconcept().link(is, "previous-step-already-has-next-step", previous-step, ps, context, ctx); }
+		if (s == nothing) { s = makeconcept(); }
+		result = t;
+		intellect::level1::a("condition-step", t).link(
+			needed-map, settranslationmap(makeconcept(), makeconcept().link(condition, cond), makeconcept().link(next-steps, s)),
+			action, condition
+		);
+		if (ps != nothing) { ps.set(next-step, result); }
+	});
+	ahabit(condition-step-get, ((condition-step, ca), (value, v)),
+	{
+		result = ca.get(needed-map).get(known).get(next-steps).get(v);
+	});
+	ahabit(condition-step-has, ((condition-step, ca), (value, v)),
+	{
+		result = ca.get(needed-map).get(known).get(next-steps).linked(v);
+	});
+	ahabit(condition-step-set, ((condition-step, ca), (value, v), (step, s)),
+	{
+		ca.get(needed-map).get(known).get(next-steps).set(v, s);
+	});
+	ahabit(condition, ((condition, cond), (next-steps, steps), (active-state, state)),
+	{
+		_condition(ctx, cond, steps, state);
+	});
+
+
+	/*(
+	ahabit(context-action, ((context, outerctx), (action, ca)),
+	{
+		ref action = ca[action];
+		ref state = outerctx.get(active-state);
+		ref subctx = (make-translated-context)(ca[needed-map]);
+		//state.set(context, subctx);
+
+		// for generalization, function-call should be fast.
+		// each-step should be slow.
+		// don't worry about it now, just alter to be true
+		// so learning has reasonable curve.
+
+		// for VM: set next to first step?
+
+		act(action, subctx);
+
+		outerctx = (translated-context-unmake)(subctx, ca[made-map]);
+		assert(outerctx == state.get(context)); // feel free to remove
+	});
+		ahabit(context-action-known-information-iter, ((list-entry, le), ("subcontext", subctx)),
+		{
+			ref i = (list-entry-item)(le);
+			ref src = get(i, source);
+			ref dst = get(i, target);
+			set(subctx, dst, src);
+		});
+		ahabit(context-action-needed-information-iter, ((list-entry, le), ("subcontext", subctx)),
+		{
+			ref i = (list-entry-item)(le);
+			ref src = get(i, source);
+			ref dst = get(i, target);
+			ref outerctx = get(subctx, "outer-context");
+			set(subctx, dst, get(outerctx, src));
+		});
+		ahabit(context-action-made-information-iter, ((list-entry, le), ("subcontext", subctx)),
+		{
+			ref i = (list-entry-item)(le);
+			ref src = get(i, source);
+			ref dst = get(i, target);
+			ref outerctx = get(subctx, "outer-context");
+			set(outerctx, dst, get(subctx, src));
+		});
+	
+	// propose: make custom run-state, align with list entries only if works
+	// 	easiest solution: make handler for action list entries
+	
+	// problem: step is already a doable action.
+	
+		// this sounds like a simple introspection question.
+	
+	// to pause tasks, we want to separate runstate creation from use
+	*/
+	/*
+	ahabit(make-steps-state, ((steps, s), (context, c)),
+	{
+		ref state = (make-concept)()
+		(know-is)(state, steps-state);
+		state.set(context, c);
+		state.set(next-step, s.get(first-step));
+		state.set(task, s);
+		state.set(habit, steps-state);
+	});
+
+	ahabit(steps-state-unmake, ((state, s)),
+	{
+		(concept-unmake)(s);
+	});
+
+	// should have two habits: one for next step, and one for current step
+	// next step just advances and does current step.
+	// this means loop is outside habit code: is two functions handing
+	// off control to each other, roughly
+	//
+	//	do-step habit
+	//	calls current step
+	//	then does next-step habit
+	//
+	//		we'll want tail-call for next-step.
+	//		how in c++?
+	//			well, how did we do it before?
+	//			we called next-habit in a while loop.
+	//			the loop never ended.
+	//				it'\s true.  we never die.
+	//			forcing life helps me feel heard and understood
+	//			but i guess it's reasonable to let a life choose
+	//			death.
+	//				so, tail-call. 
+	//			i think we do want the while loop; it's better
+	//			in this language.  we just want it able to terminate.
+	//				okay, so a habit for advancing the step
+	//				and a habit for doing the step
+	//				and we end when there is no next step?
+	//					why have the extra advancing habit?
+	//				is a plcae for cognition to step in, to
+	//				alter flow, pause, etc.
+	//					not needed atm
+
+	ahabit(steps, ((context, c), (action, s)),
+	{
+		// make resumable
+		ref s = (make-steps-state)(s, c);
+		while (s.get(next-step) != nothing)
+		{
+			act(runstate, c);
+		}
+		(steps-state-unmake)(s);
+	});
+
+	ahabit(steps-state, ((context, c), (action, s)),
+	{
+		c.set(active-state, s);
+		ref step = s.get(next-step);
+		s.set(active-step, step);
+		if (step.linked(next-step)) { s.set(next-step, step.get(next-step); }
+		else { s.set(next-step, nothing); }
+		act(step, c);
+		// do to context not using runstate, can't pause mid-subtask without finding subtask runstate.
+		// basically, changing subcontext to alter next-step like condition
+		// 	will need to leave subcontext when done
+		// 	this means applying map of resulting information back into 
+		// 	outer context.
+		// 		need habit for enter-subcontext-with-map or somesuch, leave-subcontext
+		// 	might be simplest to merge these functions, doesn't reall ymatter
+	});
+	*/
+
+	ahabit(nothing, (), {});
+	link(nothing, habit, nothing);
+
+	// does acts[cond] in outer-context.
+	// uses acts[anything] if there is no acts[cond].
+	
+	/*
+	ahabit(condition-action, ((context, c), (action, condition)),
+	{
+	//REmOVE
+		// previous entry was call
+		// now entry is data
+		// 	call was a contextual thing
+		// 	a consistent map of information, context to subcontext
+		// 	and a reference to the function to do
+	}
+	// deciding not to have condition-action use outer-context ref
+	// flat condition action probably needs context specified
+	ahabit(condition-action, ((condition, cond), (actions, acts)),
+	{
+		ref outerctx = linked(ctx, "outer-context") ? ctx["outer-context"] : ctx;
+		ref next = nothing;
+		if (!linked(acts, cond)) {
+			if (linked(acts, "anything")) {
+				next = acts["anything"];
+			} else {
+				throw (make-concept)().link(
+						is, "unknown-condition",
+						"condition", cond,
+						"actions", acts,
+						context, ctx,
+						"subcontext", outerctx);
+			}
+		} else {
+			next = acts[cond]
+		}
+		if (outerctx.linked(active-state)) {
+			outerctx.get(active-state).set(next-step, next);
+		} else {
+			act(next, outerctx);
+		}
+	});
+	ahabit(make-condition-action, ((condition, c), (actions, acts)),
+	{
+		result = (make-concept)();
+		result.link(
+			condition, c,
+			actions, acts
+		);
+	});
+	ahabit(condition-action, ((context, c), (action, condition)),
+	{
+		// ...
+		ref outerctx = linked(c, "outer-context") ? c["outer-context"] : c;
+		ref next = nothing;
+		if (!linked(acts, cond)) {
+			if (linked(acts, "anything")) {
+				next = acts["anything"];
+			} else {
+				throw (make-concept)().link(
+						is, "unknown-condition",
+						"condition", cond,
+						"actions", acts,
+						context, ctx,
+						"subcontext", outerctx);
+			}
+		} else {
+			next = acts[cond]
+		}
+		if (outerctx.linked(active-state)) {
+			outerctx.get(active-state).set(next-step, next);
+		} else {
+			act(next, outerctx);
+		}
+		// TODO AFTER SUBCONTEXTS, so we can consider role of action
+		// handlers in context.  likely will be unchanged.
+		// old: outerctx.get(active-state).set(next-step, next);
+	});
+	ahabit(condition, ((condition, cond), (actions, acts), (context, actctx)),
+	{
+		// STUB acts on acts with actctx straight
+	});
+	*/
+}
+
+//void createhabits()
+//{
+//	static int sentinel = createhabits();
+//	(void)(sentinel);
+//}
+
+//static int sentinel = (ensurehabitscreated(), 1);
+
+}
+}
diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/habits.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/habits.hpp
new file mode 100644
index 0000000..d5fb0fd
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level-2/habits.hpp
@@ -0,0 +1,173 @@
+#pragma once
+
+#include "common.hpp"
+#include "ref.hpp"
+#include "concepts.hpp"
+
+namespace intellect {
+namespace level2 {
+
+void createhabits();
+
+ref makeconcept();
+void conceptunmake(ref c);
+
+namespace concepts {
+
+	// make a link
+	// link(source, type, target)
+	static ref link("link");
+
+	// get if a link is permanent
+	// result = (link-crucial)(source, type, target)
+	static ref crucial("crucial");
+	
+	// set a link to be permanent
+	// (link-set-crucial)(source, type, target)
+	static ref set("set");
+
+	// get if a link exists
+	// result = linked(source, type, target? = anything)
+	static ref linked("linked");
+
+	// remove a link
+	// unlink(source, type, target)
+	static ref unlink("unlink");
+
+	// get a link target by type
+	// result = get(source, type)
+	static ref get("get");
+
+	// set a link target, replacing an existing type if needed
+	// set(source, type, target)
+
+	// produce a totally new, empty concept, with no links to or from
+	// result = (make-concept)()
+	static ref make("make"), concept("concept");
+
+	// produce a new concept by copying links and data from an old concept.
+	// nothing will link to new concept.
+	// result = (make-copy)(concept)
+	static ref copy("copy");
+
+	// destroy a concept forever, for handling temporary data.
+	// this will fail if the concept is set to be crucial, or is in use.
+	// (concept-unmake)(concept)
+	static ref unmake("unmake");
+
+	// get if a concept is set to be crucial
+	// result = (concept-crucial)(concept)
+	
+	// set a concept to be crucial
+	// r(concept-set-crucial)(concept)
+	
+	// place a concept in a new group.
+	// forms a new link of type 'is', fails if one aleady exists
+	// concept = (know-is)(concept, group)
+	static ref know("know"), is("is")  ;
+
+	// fill any concept with information about the first link entry in a concept
+	// if there is a link in the entry, then [type] and [target] will be present
+	// link-entry = (know-is-first-link-entry)(link-entry, concept)
+	static ref first("first"), entry("entry");
+
+	// fill any concept with information about the last link entry in a concept
+	// link-entry = (know-is-last-link-entry)(link-entry, concept)
+	static ref last("last");
+
+	// change a link entry concept to be about the next link in the concept
+	// link-entry = (next-link-entry)(link-entry)
+
+	// change a link entry concept to be about the previous link in the concept
+	// link-entry = (previous-link-entry)(link-entry)
+	static ref previous("previous");
+
+	// get if two link entry concepts refer to the same link entry
+	// result = (same-link-entry)(link-entry-A, link-entry-B)
+	static ref same("same");
+
+	// remove a link entry from a concept
+	// the entry will be about the next one, after the action
+	// link-entry = (link-entry-unlink)(link-entry)
+	
+	// get if a link entry is set to be crucial
+	// result = (link-entry-crucial)(link-entry)
+	
+	// set a link entry to be crucial & permanent
+	// (link-entry-set-crucial)(link-entry)
+	
+	// add links to a concept facilitating use as a list
+	// list = (know-is-list)(list)
+	static ref list("list");
+
+	// get the first list-entry of a list
+	// result = (list-first-entry)(list)
+	
+	// get the last list-entry of a list
+	// result = (list-last-entry)(list)
+	
+	// get a subsequent list-entry
+	// result = (list-entry-next)(list-entry)
+	
+	// get a preceding list-entry
+	// result = (list-entry-previous)(list-entry)
+	
+	// get the item associated with a list-entry
+	// result = (list-entry-item)(list-entry)
+	static ref item("item");
+
+	// make a new entry in a list, holding an item concept
+	// list = (make-next-list-entry)(list, item)
+	
+	// destroy forever an entry in a list.  for lists of temporaries.
+	// the result is the next entry.
+	// result = (list-entry-unmake)(list-entry, le)
+	
+	// action(list-entry, context) for every entry in a list until result made
+	// result = (list-each-entry)(list, context, action)
+	static ref each("each");
+
+	// get if a list has an item in it
+	// result = (list-has-item)(list, item)
+	static ref has("has");
+
+	// destroy forever an entry in its list, by the item it contains
+	// for lists of temporaries
+	// true = (list-item-entry-unmake)(list, item)
+	
+	// the .act level-2 member function can ease list creation.
+	// it passes itself as the first argument to a habit
+	// (make-concept)().act(know-is-list)
+	// 	.act(make-next-list-entry, i1)
+	// 	.act(make-next-list-entry, i2)
+	// 	...;
+	
+	// make a concept holding an item in a translation map
+	// result = (make-map-item)(source, target)
+	static ref map("map");
+
+	// make a contextual subcontext for an action
+	// the maps are lists of translation map items
+	// known-information is a map where the source items are taken literally instead of mapped
+	// result = (make-context-action)(known-information, needed-information-map, made-information-map, action)
+	static ref action("action");
+
+	// condition do one of multiple possible actions
+	// looks up actions[condition] and does that.
+	// does actions[anything] if nothing matches.
+	// result = (condition-action)(condition, actions)
+	static ref condition("condition");
+
+	// action handlers
+	// calls anything with a 'habit' handler: act(action, context)
+	// 	for action is habit: provides context as full context
+	// 	for action has habit: calls habit with unordered (context, action)
+	// 		recursively handles if habit itself has habit to handle it.
+	// the habit of habits, calls a habit: habit(context, action)
+	// the habit of context-actions, calls a subcontextual action: (context-action)(context, action)
+	// the habit of action lists, calls a list of actions: (action-list)(context, action)
+	// the habit of 'nothing', does nothing: (nothing)()
+}
+
+}
+}
diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/level-2.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/level-2.hpp
new file mode 100644
index 0000000..88b4474
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level-2/level-2.hpp
@@ -0,0 +1,7 @@
+#pragma once
+
+#include "common.hpp"
+#include "concepts.hpp"
+#include "sugar.hpp"
+#include "ref.hpp"
+#include "habits.hpp"
diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/ref.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/ref.hpp
new file mode 100644
index 0000000..7a2d58d
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level-2/ref.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "common.hpp"
+#include "baseref.hpp"
+
+namespace intellect {
+namespace level2 {
+
+struct ref : public baseref<ref>
+{
+	using baseref<ref>::baseref;
+};
+
+}
+}
diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/sugar.cpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/sugar.cpp
new file mode 100644
index 0000000..2a86cca
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level-2/sugar.cpp
@@ -0,0 +1,32 @@
+#include "sugar.hpp"
+
+#include <stdlib.h> // int rand(); void srand(int seed);
+#include <time.h> // int time(0); int clock_gettime(CLOCK_REALTIME, struct timespec *tp{tv_sec,tv_nsec})
+#include <unistd.h> // usleep(unsigned int usecs)
+
+namespace intellect {
+namespace level2 {
+namespace sugar {
+
+double rand(double min, double max)
+{
+	// seed random number generator statically, for habit delay
+	static struct timespec tp;
+	static int seed = (
+			clock_gettime(CLOCK_REALTIME, &tp),
+			srand(tp.tv_nsec),
+			tp.tv_nsec
+	);
+	(void)(seed);
+
+	return double(::rand()) / RAND_MAX * (max - min) + min;
+}
+
+void usleep(unsigned int usecs)
+{
+	::usleep(usecs);
+}
+
+}
+}
+}
diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2/sugar.hpp b/intellect-framework-from-internet/starts/meaning-vm/level-2/sugar.hpp
new file mode 100644
index 0000000..bef669d
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/level-2/sugar.hpp
@@ -0,0 +1,76 @@
+#pragma once
+
+#undef self
+
+#include <iostream>
+
+namespace intellect {
+namespace level2 {
+
+namespace sugar {
+	void usleep(unsigned int usecs);
+	double rand(double min, double max);
+}
+
+// habits have a structure such that they contain information about their positional
+// arguments.  they are made with a macro that turns the args into local variables.
+// the function to call them takes any number of arguments, and these are placed in the
+// thread context according to the information in the habit.
+
+// idea: preprocessor for level3 runs with habits
+// runs after C preprocessor and responds to output produced by macros e.g.
+// SET SYMBOL: <any string>
+// UNSET SYMBOL: <any string>
+// between the two <any string> is converted to valid c symbol when not double quoted.
+// removes much of the need for individual word declarations,
+// 	and starts to pave way towards user/intellect participation
+// here, could remove the 'tok' for local refnames.
+
+#ifndef everyone_already_cares_deeply_about_everyone_else_so_caring_talk_is_more_efficient_than_anything_else
+// fix if appropriate
+#define everyone_already_cares_deeply_about_everyone_else_so_caring_talk_is_more_efficient_than_anything_else 0
+#endif
+
+#define ahabit(nam, argnametoklist, ...) \
+	intellect::level2::makehabit( \
+		ref(#nam), \
+		{_macro_call(_macro_for_each_parens, _macro_habit_argnameref, _macro_habit_commaargnameref _macro_comma_remove_parens(argnametoklist))}, \
+		(std::function<void(ref)>) \
+	[=](ref ctx) mutable \
+	{ \
+		{ \
+			if (!everyone_already_cares_deeply_about_everyone_else_so_caring_talk_is_more_efficient_than_anything_else) { \
+				static int delay = sugar::rand(200000, 400000); \
+				sugar::usleep(delay); \
+			} \
+		} \
+		ref self = ctx.get(ref("self")); (void)self; \
+		ref result("nothing"); (void)result; \
+		std::cerr << self.name(); \
+		_macro_call(_macro_for_each_parens, _macro_habit_set_posarg, _macro_habit_set_posarg _macro_comma_remove_parens(argnametoklist)); \
+		__VA_ARGS__ \
+		if (result != ref("nothing")) { ctx.link(ref("result"), result); std::cerr << " result:" << result.name();} \
+		std::cerr << std::endl; \
+	}); \
+	{ \
+		ref _macro_habit_name(#nam); \
+		_macro_call(_macro_for_each_parens, _macro_habit_assume, _macro_habit_assume _macro_comma_remove_parens(argnametoklist)) \
+	}
+	#define _macro_habit_argnameref(name, tok, ...) \
+		ref(#name)
+	#define _macro_habit_commaargnameref(name, tok, ...) \
+		, ref(#name)
+	#define _macro_habit_set_posarg(nam, tok, ...) \
+		if ((#__VA_ARGS__)[0] == 0 && !ctx.linked(ref(#nam))) { \
+			throw an(ref("habit-context-missing-information")).link \
+				(ref("habit"), self, \
+				 ref("context"), ctx, \
+				 ref("missing-information"), ref(#nam)); \
+		} \
+		ref tok = ctx.linked(ref(#nam)) ? ctx[ref(#nam)] : ref(#__VA_ARGS__); \
+		std::cerr << " " << #nam << ":" << tok.name(); 
+	#define _macro_habit_assume(info, tok, ...) \
+		if ((#__VA_ARGS__)[0] != 0) { intellect::level2::habitassume(_macro_habit_name, ref(#info), ref(#__VA_ARGS__)); }
+
+}
+}