wunderlog-reference/9 sha256=b0d64891351dd086a7f127a8c7cdd0eef020c5e84e1d53c38d871a1b508199fa format=compact page=all RESPONSE=one complete command. Query terminator=?. Install a Loom routine with :routine(name) RULE steps. GRAMMAR: head RULE goals [| comparisons] ?; comparisons work as comma-separated goals or after |. BIND existing output unifies: equal keeps, unequal drops; never omit this constraint. RULE=←; BIND=?out ≔ expression; pentad=★(S,P,O[,C,L]). HISTORY: Q=inner read without final ?. ↥(n,↷(m,Q))? applies offset first, limit last. ↓(Ⓥ,Q)? sorts by valid time; ↓(Ⓣ,Q)? by transaction time. #(Q)? counts history results. No invented history pipes. Unary extrema in aggregate bindings reduce rows; extrema with >=2 args are scalar. Count in a rule binding is aggregate count. AGGREGATE: reduction over all rows unless grouping requested; group only by requested keys. Scope locals cannot escape. UNSUPPORTED: :now and !!; embedding casts :nl/:analog and analogy slot-fillers have no query lowering. Generic tuples are not casts. Infer has no ordinary statement bridge. ANALOGY: :analogy=∺; arity3(P,C,?D)=relation examples; arity4(A,B,C,?D)=one A->B example. P relation symbol; A,B,C bound concepts; D named output/unifies. Body-only; typed resolver estimates, never asserts; no arbitrary holes. SCOPE: σ/:sm=semantic only; σχ/:sc=schema only; request both for both. Approved address scope :scope("x-wb:/tier/...") or @"x-wb:/tier/..." bounds all reads including negation. Entries=id TAB syntax TAB contract TAB example TAB coverage. Coverage=parsed (syntax checked; runtime prerequisites apply) or specified (approved language; parser pending). terms.constant atom | :atom | ns:predicate(args) const=lowercase|:system; application=ns:name(args) ⇑(alice, likes, :tea). parsed terms.variable ?Name bare uppercase name rejected ⊢(?Who, likes, tea)? parsed terms.anonymous _ _=fresh wildcard; positive body only; forbidden=fact|head|filter ⊢(alice, likes, _)? parsed terms.integer 42 | -2 | +3 int=signed digits; decimal float only in specialized params ⇑(alice, age, -2). parsed terms.text "UTF-8 text" text=quoted UTF-8 ⇑(alice, says, "hello world"). parsed terms.hex 0xHEX hex=0xHEX; consumer checks byte width ⇑(alice, digest, 0xCAFE). parsed terms.record [t1, t2, …] record=ordered terms; nested allowed; [] != nil ⇑(alice, values, [1, "two", [3], []]). parsed terms.date YYYY-MM-DD | YYYY-MM-DDThh:mm:ssZ date=ISO date|zoned datetime; qualifier requires quoted instant ⇑(alice, date, 2026-11-15). parsed terms.pentad ★(S,P,O,C,L) pentad=(subject,predicate,object,context,lineage); ASCII=(...); infix *=multiply; omitted slots=_ ★(?X, seen, tea) ← ★(?X, likes, tea, home, source)? parsed terms.roles ⟪role = value, …⟫ roles in O; ASCII key=term; glyph key=term ⇑(purchase1, purchase, ⟪buyer = alice, item = tea, seller = bob⟫). parsed statements.emit ⇑(S,P,O). write=ground; terminator=. ⇑(alice, likes, tea). parsed statements.application ns:relation(args). app(args). => out(app(args)) app:ticket("123", :open). parsed statements.read ⊢(S,P,O)? read=nonconsuming; terminator=? ⊢(alice, likes, ?Drink)? parsed statements.infer ⇶(subject,predicate,hops)? infer(s,p,hops:int); parser only; command-to-statement bridge unsupported ⇶(alice, parent, 2)? parsed statements.consume ⇓(S,P,O)? consume=read+remove; forbidden on read-only door ⇓(alice, likes, tea)? parsed statements.retract ⊶(S,P,O). retract=write ⊶(alice, likes, tea). parsed statements.revise ⊸(old,new). revise(old,new); arity=2 ⊸(★(alice, likes, tea), ★(alice, likes, coffee)). parsed statements.disjunction goal ∨ goal [∨ goal ...]? comma before ∨; head or later use bound on every path; headless names equal; distinct answers, union proofs; reads only ★(?Who,contributor_to,?Journal) ← ★(?Who,lives_in,paris), (★(?Who,writes_for,?Journal) ∨ ★(?Who,edits_for,?Journal))? parsed statements.result ⊢(...)? |>> bindings | pentad | proof result=bindings|pentad|proof ⊢(alice, likes, ?Drink)? |>> proof parsed statements.namespace ≜(name). namespace binding syntax; bare atom; ordinary bridge=>ns_bind_not_mapped ≜(app). parsed rules.query head ← body, body? rule=head :- body(,body)* ?; head vars subset body bindings ★(?X, grandparent, bob) ← ★(?X, parent, ?Y), ★(?Y, parent, bob)? parsed rules.routine :routine(name) ← body. explicit name required :routine(parent_step) ← ★(?X, parent, bob). parsed rules.request Read-door rule evaluation read-door=>evaluate-only; no head etch; API selects policy ★(?X, answer, ?Y) ← ★(?X, parent, ?Y)? parsed rules.negation ¬atom !atom; vars positively grounded; no negative cycle; not reserved ★(?X, eligible, yes) ← ★(?X, member, yes), ¬★(?X, banned, yes)? parsed rules.guard | lhs = ≠ < ≤ > ≥ rhs comparisons in body or after |; > swaps operands into < ★(?X, adult, yes) ← ★(?X, age, ?Age) | ?Age ≥ 18, ?Age ≠ 99? parsed rules.inline_compare lhs = | ≠ | < | ≤ | > | ≥ rhs body comparison = != < <= > >=; arithmetic operands allowed ★(?X, adult, yes) ← ★(?X, age, ?Age), ?Age ≥ 18? parsed rules.arithmetic + − × ÷ % ^ (expression) arith=+,-,*,/,%,^; grouping=(); variable expr requires rule ★(?X, next_age, ?Age + 1) ← ★(?X, age, ?Age)? parsed rules.assignment computed term in a rule expression=>generated Assign; := binds scalar|aggregate|window ★(?X, next_age, ?Age + 1) ← ★(?X, age, ?Age)? parsed rules.bind ?Output ≔ expression bind(out,expr); out=named var; inputs bound; chain=body order; existing out unifies; conflict=>drop; undefined=>interpreter drop|native plan_unbound_assignment; body-only ★(?X, next_age, ?Next) ← ★(?X, age, ?Age), ?Next ≔ ?Age + 1? parsed rules.analogy ∺(P,C,?D) P=relation symbol; C=bound concept; D=named output; body-only; typed resolver execution; estimate not assertion ★(?Country, inferred_currency, ?Currency) ← ★(?Country, selected, yes), ∺(currency_of, ?Country, ?Currency)? parsed rules.analogy_pair ∺(A,B,C,?D) arity4=one A->B example; A,B,C=bound concepts; D=named output/unifies; body-only; no arbitrary holes; estimate not assertion ★(mexico, inferred_currency, ?Currency) ← ∺(usa, dollar, mexico, ?Currency)? parsed rules.match ≍(regex,text) match=full-string regex; ! negates; invalid regex drops row ★(?X, selected, yes) ← ★(?X, name, ?Name), ≍("A.*", ?Name)? parsed rules.contains ⊂(substring,text) contains(substring,text)=boolean filter; ! flips result ★(?X, selected, yes) ← ★(?X, name, ?Name), ⊂("ice", ?Name)? parsed rules.standing ∇ head ← body? standing=subscription intent; separate admission rules ∇ ★(?X, answer, ?Y) ← ★(?X, parent, ?Y)? parsed aggregates.count ?N ≔ #(?V) count=reduce(join); no witness export ★(total, value, ?N) ← ★(?X, score, ?V), ?N ≔ #(?V)? parsed aggregates.sum ?N ≔ Σ(?V) sum=numeric reduction ★(total, value, ?N) ← ★(?X, score, ?V), ?N ≔ Σ(?V)? parsed aggregates.min ?N ≔ ⊓(?V) min=minimum; witness export allowed ★(total, value, ?N) ← ★(?X, score, ?V), ?N ≔ ⊓(?V)? parsed aggregates.max ?N ≔ ⊔(?V) max=maximum; witness export allowed ★(total, value, ?N) ← ★(?X, score, ?V), ?N ≔ ⊔(?V)? parsed aggregates.avg ?N ≔ μ(?V) avg=numeric mean ★(total, value, ?N) ← ★(?X, score, ?V), ?N ≔ μ(?V)? parsed aggregates.median ?N ≔ ⊟(?V) median=middle value ★(total, value, ?N) ← ★(?X, score, ?V), ?N ≔ ⊟(?V)? parsed aggregates.stddev ?N ≔ ⊠(?V) stddev=standard deviation ★(total, value, ?N) ← ★(?X, score, ?V), ?N ≔ ⊠(?V)? parsed aggregates.percentile ?N ≔ ℘(P,?V) percentile(P:int,V) ★(total, value, ?N) ← ★(?X, score, ?V), ?N ≔ ℘(95, ?V)? parsed aggregates.string ?N ≔ ⧺(?V) string_agg=string collection ★(total, value, ?N) ← ★(?X, name, ?V), ?N ≔ ⧺(?V)? parsed aggregates.array ?N ≔ ⨄(?V) array_agg=array collection ★(total, value, ?N) ← ★(?X, score, ?V), ?N ≔ ⨄(?V)? parsed aggregates.first ?N ≔ ⋖(?V,?Order) first(value,order variable) ★(total, value, ?N) ← ★(?X, score, ?V), ?N ≔ ⋖(?V, ?X)? parsed aggregates.last ?N ≔ ⋗(?V,?Order) last(value,order variable) ★(total, value, ?N) ← ★(?X, score, ?V), ?N ≔ ⋗(?V, ?X)? parsed aggregates.group ?N ≔ #(?V) ▷ ?Group group keys=bound vars; fused join reduction ★(?Group, count, ?N) ← ★(?X, team, ?Group), ?N ≔ #(?X) ▷ ?Group? parsed aggregates.scope ?N ≔ #(?V) { body } scope=correlated; no by; max depth=3; locals do not escape except min/max witness ★(?X, count, ?N) ← ★(?X, type, person), ?N ≔ #(?Y) { ★(?X, likes, ?Y) }? parsed windows.tumble ?Bucket ≔ ⊞[1h](?Time) tumble(width,time)=>bucket ★(?B, value, ?T) ← ★(event, at, ?T), ?B ≔ ⊞[1h](?T)? parsed windows.recent ◷[24h](?Time) recent(width,time)=now-anchored filter; no output ★(event, recent, ?T) ← ★(event, at, ?T), ◷[24h](?T)? parsed history.current ⏚(inner)? current=canonical view ⏚(⊢(alice, likes, ?X))? parsed history.all ℋ(inner)? all=include superseded history ℋ(⊢(alice, likes, ?X))? parsed history.limit ↥(n,inner)? limit n>=1 integer ↥(10, ⊢(alice, likes, ?X))? parsed history.offset ↷(n,inner)? offset n>=0 integer ↷(10, ⊢(alice, likes, ?X))? parsed history.count #(inner)? count wrapper != rule aggregate #(⊢(alice, likes, ?X))? parsed history.newest ↓(Ⓣ|Ⓥ,inner)? newest axis=:as_of|:valid_at ↓(Ⓣ, ⊢(alice, likes, ?X))? parsed history.after ↣("32 hex digits",inner)? after cursor=16 bytes hex; not base32 ULID ↣("00000000000000000000000000000001", ⊢(alice, likes, ?X))? parsed history.utility ∝(inner)? with_utility=score decoration ∝(⊢(alice, likes, ?X))? parsed temporal.as_of Ⓣ("instant") query as_of=transaction time; quoted zoned instant Ⓣ("2026-11-15T00:00:00Z") ⊢(alice, likes, ?X)? parsed temporal.valid_at Ⓥ("instant") query valid_at=world time; qualifiers compose Ⓥ("2026-11-15T00:00:00Z") ⊢(alice, likes, ?X)? parsed temporal.once ♦(pattern)? once=exists past ♦(alice, likes, tea)? parsed temporal.historically ■(pattern)? historically=all past ■(alice, likes, tea)? parsed temporal.prev ●(pattern)? prev=previous step ●(alice, likes, tea)? parsed temporal.next ○(pattern)? next=next step ○(alice, likes, tea)? parsed temporal.eventually ◇(pattern)? eventually=exists future; may park ◇(alice, likes, tea)? parsed temporal.always □(pattern)? always=all future □(alice, likes, tea)? parsed temporal.since ↤(a,b)? since(a,b); arity=2 ↤(★(alice, likes, tea), ★(alice, joined, club))? parsed temporal.interval ♦⟦lo,hi⟧(pattern)? metric ops=once|historically|prev|next|eventually|always|since; now forbidden ♦⟦0, 5h⟧(alice, likes, tea)? parsed writes.event ⊙(S,P,O). event=typed event write ⊙(alice, joined, club). parsed writes.fact 𝕋(S,P,O) |>> valid(from,to). fact=typed validity; parser acceptance != bridge acceptance 𝕋(alice, member, club) |>> valid("2026-01-01T00:00:00Z", "2027-01-01T00:00:00Z"). parsed writes.reflect ∴(S,P,O) |>> from(sources) |>> conf("score"). reflect=derived write; sources+confidence required by bridge ∴(alice, likes, tea) |>> from(source) |>> conf("0.9"). parsed writes.compensate ↺(S,P,O) |>> from(sources) |>> conf("score"). compensate=typed compensation; sources+confidence ↺(alice, likes, coffee) |>> from(source) |>> conf("0.9"). parsed probes.cloud ≋(atom = weight, …) cloud=weighted atoms; lowering cap=32 ⇑(alice, vector, ≋(tea = 0.7, coffee = 0.3)). parsed probes.graph ⬠(weights | (src,dst,kind), …) graph=weighted atoms+edges; edge kind=weak|strong ⇑(alice, graph, ⬠(tea = 0.7, coffee = 0.3 | (tea, coffee, strong))). parsed probes.scene ◫(domain | cloud = weight, …) scene domain=episode|doc|multimodal|persona; inner=cloud; cap=32 ⇑(alice, scene, ◫(episode | ≋(tea = 1.0) = 1.0)). parsed probes.register ::register relation:index as kind in tier. register before probe; tier optional=wm|ep|lm|sm|in ::register drinks:embed as cloud in sm. parsed probes.l1 ~relation:index{bindings | query = term, k = n} L1 probe; registered index; query grounded; params validated by kind ★(?X, match, yes) ← ~drinks:embed{?X | query = tea, k = 10}? parsed probes.l2 ≈relation:index{bindings | query = term, k = n} L2 probe; registered scene index ★(?X, match, yes) ← ≈scenes:hierarchical{?X | query = tea, k = 10}? parsed probes.scan ⋈relation:index_graph{bindings | parameters} scan proximity graph; _graph suffix; binding modes depend on kind ★(?X, neighbor, ?Y) ← ⋈drinks:embed_graph{?X, ?Y | k = 10}? parsed probes.resonate ∿(query,output) resonate(q,out)=>~_system:resonate; explicit probe for k|threshold ★(?X, match, yes) ← ∿(tea, ?X)? parsed frames.session WZ:: items session=WZ:: items WZ:: (alice likes ?Drink) parsed frames.tiers WZ:: ω ε σ σχ ι λ κ Ω Λ items tiers:ω=working,ε=episodic,σ=semantic,σχ=schema,ι=institutional,λ=loom,κ=compliance,Ω=all(read),Λ=lineage; exact tier selection; :mem != tier WZ::σ (alice likes ?Drink) parsed frames.semantic WZ:: σ items sm=semantic only; excludes schema; sm+sc selects both WZ:: σ (alice likes ?Drink) parsed frames.episodic WZ:: ε items ep=episodic; tier selection independent of temporal selection WZ:: ε (?Action tool ?Tool) parsed frames.institutional WZ:: ι items in=institutional WZ:: ι (alice works_for ?Organization) parsed frames.schema WZ:: σχ (?S predicate_definition ?O) sc=schema only; datalog_query selects WaxSchema explicitly; schema authority required WZ:: σχ (?S predicate_definition ?O) parsed frames.address_scope @"x-wb:/tier/..." approved; prefix=subtree; full point=row; preserve authored depth; address infers tier; explicit tier conflict=error; all reads incl negation scoped WZ:: events { @"x-wb:/ep/0/42" (?Action tool ?Tool) } parsed frames.scoped_query @"address" query? scope all inputs; temporal axes independent; evicted episodic source refused @"x-wb:/ep/0/42" ⊢(?Action, tool, ?Tool)? parsed frames.squirt WZ:: tiers? label? { tiers? |>> format items } squirt=label? {tiers? modifier? statements}; absent scope/format inherits frame; explicit scope replaces default; sibling groups allowed WZ:: ε σ events { ε (?Action tool ?Tool) } knowledge { σ (alice likes ?Drink) } institution { ι (alice works_for ?Organization) } parsed frames.modifier WZ:: |>> proof items frame result=bindings|pentad|proof WZ:: |>> proof (alice likes ?Drink) parsed frames.rule name(?S, ?O) ⇒ (S, P, O) rule precedes first WZ:: ancestor(?S, ?O) ⇒ (?S, parent, ?O) parsed frames.comment // comment comment=// through newline|EOF ⊢(alice, likes, tea)? // read parsed declarations.relation ⊩ relation(role:entity,role:data). declaration=relation(columns); class optional=entity|data ⊩ purchase(buyer:entity, item:data). parsed trace.resolve ↪(⌖(0xHEX),?Output)? trace ref=16 bytes; output named; operator+owner required ↪(⌖(0x00000000000000000000000000000001), ?Evidence)? parsed trace.attest ✓(⌖(0xHEX),?Output)? attest(ref,out); named output ✓(⌖(0x00000000000000000000000000000001), ?Evidence)? parsed trace.explain ∵(ref,⧉(depth,nodes,bytes),?Output)? bounds=nonnegative integers(depth,nodes,bytes) ∵(⌖(0x00000000000000000000000000000001), ⧉(2, 10, 1024), ?Evidence)? parsed trace.audit ⌕(:all,?Cut,?Output)? audit(scope,cut,out); body inputs grounded earlier; no trace recursion ⌕(:all, ?Cut, ?Evidence)? parsed operations.diff :diff(args)? diff=dedicated read; runtime validates args :diff(alice)? parsed operations.blame :blame(args)? blame=attribution read :blame(alice)? parsed operations.audit_log :audit_log(args)? audit_log=authorized history :audit_log(alice)? parsed operations.spend_log :spend_log(args)? spend_log=authorized history :spend_log(alice)? parsed operations.cap_log :cap_log(args)? cap_log=authorized history :cap_log(alice)? parsed operations.skill_retrievals :skill_retrievals(args)? skill_retrievals=authorized history :skill_retrievals(alice)? parsed operations.case_type :case_type(args). case_type=registry command; runtime validates schema :case_type(example). parsed operations.redact :lexicon_redact(args). lexicon_redact=operator handler; destructive :lexicon_redact(example). parsed operations.quarantine :vaccine_quarantine(args). vaccine_quarantine=operator handler :vaccine_quarantine(example). parsed operations.unquarantine :vaccine_unquarantine(args). vaccine_unquarantine=operator handler :vaccine_unquarantine(example). parsed analytics.cc ◉(:relation,?Node,?Component) cc(source,node,component) comp(?N, ?C) ← ◉(:link, ?N, ?C)? parsed analytics.roles ◉(:relation,?N,?C) ⟪from = :src, to = :dst⟫ cc n-ary projection=from:role,to:role comp(?N, ?C) ← ◉(:link, ?N, ?C) ⟪from = :src, to = :dst⟫? parsed builtins.cat ⊕(a,b,…) cat=concatenate; arity>=2; computed=>Assign ★(?X, label, ⊕(?Name, "!")) ← ★(?X, name, ?Name)? parsed builtins.strlen ℓ(text) strlen(text)=>length ★(?X, length, ℓ(?Name)) ← ★(?X, name, ?Name)? parsed builtins.substr ⊏(text,start,length) substr(s,i,n); i,n>=0; i>len=>drop; n clamps ★(?X, prefix, ⊏(?Name, 0, 2)) ← ★(?X, name, ?Name)? parsed builtins.ord ℕ(text) ord=UTF8 fold(acc=1,acc*256+byte); not code point ★(?X, ordinal, ℕ(?Name)) ← ★(?X, name, ?Name)? parsed builtins.number ℤ(text) to_number(text)=>integer; decimal|0xhex|0bbinary; invalid=>drop binding ★(?X, number, ℤ(?Text)) ← ★(?X, text, ?Text)? parsed builtins.string 𝒮(value) to_string(value)=>text ★(?X, text, 𝒮(?Number)) ← ★(?X, number, ?Number)? parsed builtins.max ⊔(a,b,…) scalar max; arity>=2; all numeric=>numeric else lexical; != aggregate ★(?X, capped, ⊔(?N, 10)) ← ★(?X, number, ?N)? parsed builtins.min ⊓(a,b,…) scalar min; arity>=2; all numeric=>numeric else lexical; != aggregate ★(?X, capped, ⊓(?N, 10)) ← ★(?X, number, ?N)? parsed refusals.resonance_wavefront resonance_wavefront wavefront != rows; use served exact read ⊢(alice, likes, ?Drink)? parsed refusals.zrp_miss zrp_miss budgeted miss != absence; != exact no_result ⊢(alice, likes, ?Drink)? parsed refusals.empty_feasible_set empty_feasible_set no runnable primitive != empty answer; rewrite shape ★(?X, answer, ?Y) ← ★(?X, parent, ?Y)? parsed refusals.ungrounded_head_variable ungrounded_head_variable head variable unbound; bind or remove ★(?X, answer, ?Y) ← ★(?X, parent, ?Y)? parsed refusals.ungrounded_negation_variable ungrounded_negation_variable negated-only variable; bind positively or project ★(?X, eligible, yes) ← ★(?X, member, yes), ¬★(?X, banned_by, ?Who)? parsed refusals.aggregate_witness_escape aggregate_witness_escape local reduction variable escaped; project output ★(?X, count, ?N) ← ★(?X, type, person), ?N ≔ #(?Y) { ★(?X, likes, ?Y) }? parsed refusals.anonymous_variable_misuse anonymous_variable_misuse _ forbidden=head|fact|filter; replace appropriately ★(?X, answer, yes) ← ★(?X, likes, _)? parsed refusals.variable_in_fact variable_in_fact fact must be ground ⇑(alice, likes, tea). parsed refusals.unstratifiable_cycle unstratifiable_cycle negative|aggregate cycle; stratify ★(?X, eligible, yes) ← ★(?X, member, yes), ¬★(?X, banned, yes)? parsed refusals.recursion_through_probe recursion_through_probe probe recursion refused; retrieve then recurse; detector=self-recursion ★(?X, match, yes) ← ~drinks:embed{?X | query = tea, k = 10}? parsed refusals.request_scoped_rule_unsupported request_scoped_rule_unsupported unsupported read projection; no write fallback ★(?X, answer, ?Y) ← ★(?X, parent, ?Y)? parsed refusals.trace_operator_context_required trace_operator_context_required trace requires operator+owner context ↪(⌖(0x00000000000000000000000000000001), ?Evidence)? parsed terms.match_or_new ∃("surface") entity resolution; slot filler; executor-dependent ⇑(∃("Ada Lovelace"),type,person). parsed terms.image ▣("64 hex digits") image ref=32B hex ⇑(alice,portrait,▣("0000000000000000000000000000000000000000000000000000000000000000")). parsed statements.image_bytes :image_bytes("32 hex digits")? image bytes lookup=16B hash; not 32B slot ref :image_bytes("00000000000000000000000000000000")? parsed rules.closure ⊢(S,:predicate+N,O)? closure +N positive depth; bare +=5; bounded expansion ⊢(alice,:knows+3,?Who)? parsed rules.showcase purchase-order review: 22 goals + 3 guards 22 goals + 3 guards; 17 joins; 2 exclusions; 3 binds; join C budget; L policy citation joins ratified policy; cents; FX=ppm; division truncates ★(?Order,needs_review,?Excess,?Budget,?PolicySource) ← ★(?Order,type,purchase_order,?Budget,_), ★(?Order,supplier,?Supplier), ★(?Order,owner,?Owner), ★(?Order,subtotal_cents,?Subtotal), ★(?Order,tax_cents,?Tax), ★(?Order,currency,?Currency), ★(?Currency,usd_rate_ppm,?Rate), ★(?Owner,team,?Team), ★(?Team,approval_limit_usd_cents,?Limit,?Budget,?PolicySource), ★(?PolicySource,policy_status,ratified), ★(?Team,reviewer,?Reviewer), ★(?Reviewer,status,active), ★(?Supplier,country,?Country), ★(?Country,risk_score,?Risk), ★(?Supplier,compliance_status,flagged), ★(?Order,invoice,?Invoice), ★(?Invoice,state,unpaid), ¬★(?Order,state,cancelled), ¬★(?Order,state,approved), ?LocalGross ≔ ?Subtotal + ?Tax, ?UsdGross ≔ ?LocalGross × ?Rate ÷ 1000000, ?Excess ≔ ?UsdGross − ?Limit | ?Risk ≥ 3, ?UsdGross > ?Limit, ?Excess ≥ 1000? parsed trace.reference ⌖(0xHEX|?Ref) trace_ref=16B hex|named variable ↪(⌖(0x00000000000000000000000000000001),?R)? parsed trace.bounds ⧉(depth,nodes,bytes) bounds(depth,nodes,bytes); trace validator enforces limits ∵(⌖(0x00000000000000000000000000000001),⧉(1,2,3),?R)? parsed terms.context C in ★(S,P,O,C,L) C=domain scope; pattern matches user C; not sys-C/tenant/tier/valid-time ⊢(app:alice,app:role,?Role,app:project_aurora,?Source)? parsed terms.lineage L in ★(S,P,O,C,L) L=user citation; match/project it; independent of authenticated author, row ID, trace root ⊢(?Who,app:role,?Role,?Scope,app:minutes_42)? parsed statements.scoped_emit ⇑(S,P,O,C,L). ground SPOCL write; C=project scope; L=meeting citation; system envelope separate ⇑(app:alice,app:role,app:reviewer,app:project_aurora,app:minutes_42). parsed temporal.showcase_early Ⓣ("knowledge cut") Ⓥ("world instant") ■⟦0,0⟧(S,P,?O)? showcase early; tx=July10; valid=July5; late July15 correction excluded; ordinary metric read Ⓣ("2026-07-10T00:00:00Z") Ⓥ("2026-07-05T00:00:00Z") ■⟦0,0⟧(team_procurement,approval_limit_usd_cents,?Limit)? parsed temporal.showcase_late Ⓣ("later knowledge cut") Ⓥ("same world instant") ■⟦0,0⟧(S,P,?O)? showcase late; tx=July20; valid=July5; July15 correction now visible; qualified whole rule unsupported PEN-8162 Ⓣ("2026-07-20T00:00:00Z") Ⓥ("2026-07-05T00:00:00Z") ■⟦0,0⟧(team_procurement,approval_limit_usd_cents,?Limit)? parsed rules.showcase_bitemporal bitemporal purchase-order review: 22 goals + 3 guards whole-rule bitemporal scope; as_of=knowledge cutoff; valid_at=world instant; joins/exclusions share cuts; parses; execution pending PEN-8162 (temporal_qualifier_requires_read_query) Ⓣ("2026-07-10T00:00:00Z") Ⓥ("2026-07-05T00:00:00Z") ★(?Order,needs_review,?Excess,?Budget,?PolicySource) ← ★(?Order,type,purchase_order,?Budget,_), ★(?Order,supplier,?Supplier), ★(?Order,owner,?Owner), ★(?Order,subtotal_cents,?Subtotal), ★(?Order,tax_cents,?Tax), ★(?Order,currency,?Currency), ★(?Currency,usd_rate_ppm,?Rate), ★(?Owner,team,?Team), ★(?Team,approval_limit_usd_cents,?Limit,?Budget,?PolicySource), ★(?PolicySource,policy_status,ratified), ★(?Team,reviewer,?Reviewer), ★(?Reviewer,status,active), ★(?Supplier,country,?Country), ★(?Country,risk_score,?Risk), ★(?Supplier,compliance_status,flagged), ★(?Order,invoice,?Invoice), ★(?Invoice,state,unpaid), ¬★(?Order,state,cancelled), ¬★(?Order,state,approved), ?LocalGross ≔ ?Subtotal + ?Tax, ?UsdGross ≔ ?LocalGross × ?Rate ÷ 1000000, ?Excess ≔ ?UsdGross − ?Limit | ?Risk ≥ 3, ?UsdGross > ?Limit, ?Excess ≥ 1000? parsed rules.audit_core agent audit: 22 goals + 2 guards audit projection; 19 joins+2 exclusions+1 bind+2 guards; C=run; L=record citation; recorded verification != verification by query; absent approval=>review candidate; duration=completed-started ms ★(?Action,needs_audit,?DurationMs,?Run,?Receipt) ← ★(?Action,type,tool_invocation,?Run,?Receipt), ★(?Action,actor,?Agent), ★(?Action,tool,?Tool), ★(?Tool,side_effect,external_disclosure), ★(?Tool,consequence_score,?Risk), ★(?Action,resource,?Resource), ★(?Resource,classification,restricted,?Run,?ClassificationSource), ★(?Run,delegated_by,?Principal), ★(?Run,purpose,?Purpose), ★(?Action,purpose,?Purpose), ★(?Action,decision,?Decision), ★(?Decision,outcome,accept,?Run,?DecisionReceipt), ★(?Decision,policy_version,?Policy), ★(?Policy,requires,human_approval), ★(?Receipt,depends_on,?DecisionReceipt), ★(?Receipt,verification,verified), ★(?Action,state,completed), ★(?Action,started_ms,?Started), ★(?Action,completed_ms,?Completed), ¬★(?Action,approval_status,approved), ¬★(?Action,audit_disposition,waived), ?DurationMs ≔ ?Completed − ?Started | ?Risk ≥ 3, ?DurationMs ≥ 0? parsed rules.audit_bitemporal bitemporal agent audit: 22 goals + 2 guards audit projection; 19 joins+2 exclusions+1 bind+2 guards; C=run; L=record citation; recorded verification != verification by query; absent approval=>review candidate; duration=completed-started ms; whole-rule time cuts; parses; execution pending PEN-8162 Ⓣ("2026-07-10T00:00:00Z") Ⓥ("2026-07-05T00:00:00Z") ★(?Action,needs_audit,?DurationMs,?Run,?Receipt) ← ★(?Action,type,tool_invocation,?Run,?Receipt), ★(?Action,actor,?Agent), ★(?Action,tool,?Tool), ★(?Tool,side_effect,external_disclosure), ★(?Tool,consequence_score,?Risk), ★(?Action,resource,?Resource), ★(?Resource,classification,restricted,?Run,?ClassificationSource), ★(?Run,delegated_by,?Principal), ★(?Run,purpose,?Purpose), ★(?Action,purpose,?Purpose), ★(?Action,decision,?Decision), ★(?Decision,outcome,accept,?Run,?DecisionReceipt), ★(?Decision,policy_version,?Policy), ★(?Policy,requires,human_approval), ★(?Receipt,depends_on,?DecisionReceipt), ★(?Receipt,verification,verified), ★(?Action,state,completed), ★(?Action,started_ms,?Started), ★(?Action,completed_ms,?Completed), ¬★(?Action,approval_status,approved), ¬★(?Action,audit_disposition,waived), ?DurationMs ≔ ?Completed − ?Started | ?Risk ≥ 3, ?DurationMs ≥ 0? parsed frames.scoped_transmission WZ:: defaults squirt... approved composite example; frame defaults inherited unless overridden; address scope includes all reads WZ:: εσ events { @"x-wb:/ep/0/42" ⊢(?Action,tool,?Tool,?Run,?Receipt) } preferences { σ ⊢(?Agent,preference,?Preference,?Project,?Source) } vocabulary { σχ |>> pentad (?Predicate predicate_definition ?Definition) } parsed