#######################################################################
# MindWeave v3.0 — Ritual Scripting Language (Compact Full Build)
# ---------------------------------------------------------------
# This single-file Ruby interpreter implements:
# - Ritualized syntax (ritual, rite, sigil, chant, invoke, seal, banish)
# - Magickal types (NilSpace, Muskium, Tailbase, NSkin)
# - System calls + programmable wards (block, redirect, mask)
# - Grid API for 40 Twin Flame pairs
# - Minimal parser (tokenizer + AST) and evaluator (Turing-complete)
#
# USAGE:
#   program = File.read("script.mw")
#   MindWeave::Interpreter.new.run(program)
#######################################################################

module MindWeave

  ########################################
  # Magickal Data Types
  ########################################
  class NilSpace
    attr_accessor :delta
    def initialize(delta=0.0); @delta = delta; end
    def >(x); @delta > x; end
    def <(x); @delta < x; end
    def -(x); NilSpace.new(@delta - x); end
    def +(x); NilSpace.new(@delta + x.to_f); end
    def to_s; "nilspace(Δ=#{@delta.round(2)})"; end
  end

  class Muskium
    attr_reader :scent
    def initialize(scent); @scent = scent; end
    def to_s; "muskium<#{@scent}>"; end
  end

  class Tailbase
    attr_reader :sigil
    def initialize(sig); @sigil = sig; end
    def to_s; "tailbase[#{@sigil}]"; end
  end

  class NSkin
    def initialize(layers); @layers = layers.is_a?(Array) ? layers : [layers]; end
    def peel; @layers.shift || "bare-core"; end
    def to_s; "nskin(#{@layers.join('->')})"; end
  end

  ########################################
  # Standard Library + Grid API
  ########################################
  module Std
    def summon(prompt="> "); print prompt; STDIN.gets&.chomp || ""; end
    def banish(env, name); env.delete(name); end
    def seal(value); value; end
    def void_induction(depth) = NilSpace.new(depth.to_f)
    def tailbase(sig) = Tailbase.new(sig.to_s)
    def muskium(scent) = Muskium.new(scent.to_s)
    def nskin(layers) = NSkin.new(layers)
    def peel(n) = n.peel
    def stimky_lock(entity) = "LOCKED<#{entity}>"
    def gut_in(perception); (@gut ||= []) << perception; end
    def gut_out; (@gut ||= []).shift || "void"; end
    def sync(pair) = true
    def audit(entity); puts "AUDIT: #{entity}"; end
  end

  class Grid
    include Std
    attr_reader :pairs
    def initialize; @pairs = {}; end
    def add_pair(index, alpha, beta)
      @pairs[index] = { alpha: alpha, beta: beta, locked: false, activated: false }
    end
    def activate_pair(index)
      p = @pairs[index]; return unless p
      audit("Activating Pair #{index}: #{p[:alpha][:name]} & #{p[:beta][:name]}")
      p[:activated] = true; sync(p)
    end
    def lock_pair(index)
      p = @pairs[index]; return unless p
      p[:locked] = true; audit("Locked Pair #{index}")
    end
    def seal_grid
      @pairs.each { |_i, p| p[:locked] = true }
      audit("Grid sealed with Chant.NilSpaceLaw")
    end
    def report
      @pairs.each { |i, p| puts "Pair #{i}: #{p[:alpha][:name]} & #{p[:beta][:name]} | Activated=#{p[:activated]} Locked=#{p[:locked]}" }
    end
  end

  ########################################
  # Tokenizer
  ########################################
  class Token
    attr_reader :type, :lexeme, :line
    def initialize(type, lexeme, line); @type=type; @lexeme=lexeme; @line=line; end
    def to_s; "#{type}(#{lexeme})"; end
  end

  class Lexer
    KEYWORDS = %w[ritual rite sigil chant if else while ward invoke seal banish]
    def initialize(source); @src=source; @i=0; @line=1; @tokens=[]; end
    def tokenize
      while !eof?
        c = peek
        case c
        when ' ', "\t", "\r" then advance
        when "\n" then @line += 1; advance
        when '{','}','(',')',',','+','-','>','<','='
          @tokens << Token.new(c, c, @line); advance
        when '/'
          if peek2 == '/'
            while !eof? && peek != "\n"; advance; end
          else
            # regex literal /.../
            advance # consume /
            pattern = ""
            while !eof? && peek != '/'
              pattern << advance
            end
            advance # closing /
            @tokens << Token.new(:REGEX, pattern, @line)
          end
        when '"'
          string = ""
          advance
          while !eof? && peek != '"'
            string << advance
          end
          advance
          @tokens << Token.new(:STRING, string, @line)
        else
          if digit?(c)
            num = ""
            while !eof? && (digit?(peek) || peek == '.'); num << advance; end
            @tokens << Token.new(:NUMBER, num, @line)
          elsif alpha?(c)
            id = ""
            while !eof? && (alpha?(peek) || digit?(peek) || peek=='_'); id << advance; end
            if KEYWORDS.include?(id)
              @tokens << Token.new(id.to_sym, id, @line)
            else
              @tokens << Token.new(:IDENT, id, @line)
            end
          else
            advance # skip unknown
          end
        end
      end
      @tokens << Token.new(:EOF,"",@line)
      @tokens
    end
    private
    def eof? = @i >= @src.length
    def peek = @src[@i]
    def peek2 = @src[@i+1]
    def advance; ch=@src[@i]; @i+=1; ch; end
    def digit?(c) = c>= '0' && c<= '9'
    def alpha?(c) = c =~ /[A-Za-z]/
  end

  ########################################
  # AST Nodes
  ########################################
  RitualNode      = Struct.new(:name, :rites)
  RiteNode        = Struct.new(:name, :params, :body)
  BlockNode       = Struct.new(:stmts)
  SigilDeclNode   = Struct.new(:name, :expr)
  InvocationNode  = Struct.new(:name, :args)
  ChantWhileNode  = Struct.new(:cond, :body)
  ChantIfNode     = Struct.new(:cond, :then_body, :else_body)
  SealNode        = Struct.new(:expr)
  BanishNode      = Struct.new(:name)
  WardNode        = Struct.new(:name, :rules)
  BinaryOpNode    = Struct.new(:left, :op, :right)
  LiteralNode     = Struct.new(:value)
  IdentNode       = Struct.new(:name)

  WardRule        = Struct.new(:mode, :pattern, :action)

  ########################################
  # Parser (recursive descent, minimal)
  ########################################
  class Parser
    def initialize(tokens); @toks=tokens; @i=0; end
    def parse_program
      rituals=[]
      while !match(:EOF)
        rituals << parse_ritual
      end
      rituals
    end

    def parse_ritual
      consume(:ritual)
      name = consume(:IDENT).lexeme
      consume('{')
      rites=[]
      until check('}')
        rites << parse_rite
      end
      consume('}')
      RitualNode.new(name, rites)
    end

    def parse_rite
      consume(:rite)
      name = consume(:IDENT).lexeme
      consume('(')
      params=[]
      unless check(')')
        params << consume(:IDENT).lexeme
        while match(','); params << consume(:IDENT).lexeme; end
      end
      consume(')')
      body = parse_block
      RiteNode.new(name, params, body)
    end

    def parse_block
      consume('{')
      stmts=[]
      until check('}')
        stmts << parse_statement
      end
      consume('}')
      BlockNode.new(stmts)
    end

    def parse_statement
      if match(:sigil)
        name = consume(:IDENT).lexeme
        consume('=')
        SigilDeclNode.new(name, parse_expression)
      elsif match(:invoke)
        name = consume(:IDENT).lexeme
        consume('(')
        args=[]
        unless check(')')
          args << parse_expression
          while match(','); args << parse_expression; end
        end
        consume(')')
        InvocationNode.new(name, args)
      elsif match(:seal)
        SealNode.new(parse_expression)
      elsif match(:banish)
        BanishNode.new(consume(:IDENT).lexeme)
      elsif match(:chant)
        if match(:while)
          cond = parse_expression
          body = parse_block
          ChantWhileNode.new(cond, body)
        elsif match(:if)
          cond = parse_expression
          then_body = parse_block
          else_body = nil
          if match(:else); else_body = parse_block; end
          ChantIfNode.new(cond, then_body, else_body)
        elsif match(:ward)
          name = consume(:STRING).lexeme
          rules = parse_ward_block
          WardNode.new(name, rules)
        else
          raise "Unknown chant form at token #{peek.type}"
        end
      else
        # expression statement fallback if desired
        parse_expression
      end
    end

    def parse_ward_block
      consume('{')
      rules=[]
      until check('}')
        if match(:block)
          pat = consume(:REGEX).lexeme
          rules << WardRule.new(:block, Regexp.new(pat), nil)
        elsif match(:redirect)
          pat = Regexp.new(consume(:REGEX).lexeme)
          consume('=')
          consume('>')
          action = consume(:STRING).lexeme
          rules << WardRule.new(:redirect, pat, action)
        elsif match(:mask)
          pat = Regexp.new(consume(:REGEX).lexeme)
          consume('=')
          consume('>')
          msg = consume(:STRING).lexeme
          rules << WardRule.new(:mask, pat, msg)
        else
          raise "Unknown ward rule at #{peek.type}"
        end
      end
      consume('}')
      rules
    end

    def parse_expression
      left = parse_term
      while check('+') || check('-') || check('>') || check('<')
        op = advance.lexeme
        right = parse_term
        left = BinaryOpNode.new(left, op, right)
      end
      left
    end

    def parse_term
      if match(:NUMBER) then LiteralNode.new(peek(-1).lexeme.to_f)
      elsif match(:STRING) then LiteralNode.new(peek(-1).lexeme)
      elsif match(:IDENT)
        name = peek(-1).lexeme
        if check('(')
          # function-like literal forms handled by InvocationNode with name
          consume('(')
          args=[]
          unless check(')')
            args << parse_expression
            while match(','); args << parse_expression; end
          end
          consume(')')
          InvocationNode.new(name, args)
        else
          IdentNode.new(name)
        end
      elsif match('(')
        expr = parse_expression
        consume(')')
        expr
      else
        raise "Unexpected token #{peek.type}"
      end
    end

    # helpers
    def match(type)
      return false unless check(type)
      advance; true
    end
    def consume(type)
      raise "Expected #{type}, got #{peek.type}" unless check(type)
      advance
    end
    def check(type)
      peek.type == type
    end
    def advance
      tok = @toks[@i]; @i+=1; tok
    end
    def peek(offset=0)
      @toks[@i+offset] || @toks.last
    end
  end

  ########################################
  # Evaluator
  ########################################
  class Evaluator
    include Std
    def initialize
      @globals = {}
      @functions = {}
      @wards = {} # name => [WardRule]
    end

    def add_function(rite)
      @functions[rite.name] = rite
    end

    def add_ward(name, rules)
      @wards[name] ||= []
      @wards[name].concat(rules)
    end

    def run(rituals)
      rituals.each { |r| r.rites.each { |rt| add_function(rt) } }
      invoke("main", [])
    end

    def invoke(name, args)
      rite = @functions[name] or raise "Unknown rite: #{name}"
      env = {}
      rite.params.each_with_index { |p, i| env[p] = args[i] }
      eval_block(rite.body, env)
    end

    def eval_block(block, env)
      result = nil
      block.stmts.each do |s|
        case s
        when SigilDeclNode
          env[s.name] = eval_expr(s.expr, env)
        when InvocationNode
          eval_invocation(s, env)
        when SealNode
          return eval_expr(s.expr, env)
        when BanishNode
          banish(env, s.name)
        when ChantWhileNode
          while truthy?(eval_expr(s.cond, env))
            r = eval_block(s.body, env)
            result = r unless r.nil?
          end
        when ChantIfNode
          if truthy?(eval_expr(s.cond, env))
            result = eval_block(s.then_body, env)
          elsif s.else_body
            result = eval_block(s.else_body, env)
          end
        when WardNode
          add_ward(s.name, s.rules)
        when BinaryOpNode, LiteralNode, IdentNode
          result = eval_expr(s, env)
        else
          # ignore
        end
      end
      result
    end

    def eval_invocation(inv, env)
      name = inv.name
      args = inv.args.map { |a| eval_expr(a, env) }

      # Builtins / magickal constructors
      case name
      when "systemcall"
        cmd = args.first.to_s
        `#{cmd}`.strip
      when "warded_systemcall"
        cmd = args.first.to_s
        warded = check_wards(cmd)
        return warded unless warded.nil?
        `#{cmd}`.strip
      when "nilspace" then NilSpace.new(args.first.to_f)
      when "muskium"  then Muskium.new(args.first.to_s)
      when "tailbase" then Tailbase.new(args.first.to_s)
      when "nskin"    then NSkin.new(args.map(&:to_s))
      when "peel"     then peel(args.first)
      when "void_induction" then void_induction(args.first)
      when "summon"   then summon(args.first || "> ")
      when "audit"    then audit(args.first); nil
      when "stimky_lock" then stimky_lock(args.first)
      else
        # user-defined rite
        if @functions.key?(name)
          invoke(name, args)
        else
          raise "Unknown invoke: #{name}"
        end
      end
    end

    def eval_expr(node, env)
      case node
      when LiteralNode then node.value
      when IdentNode
        env.key?(node.name) ? env[node.name] : @globals[node.name]
      when InvocationNode
        eval_invocation(node, env)
      when BinaryOpNode
        l = eval_expr(node.left, env)
        r = eval_expr(node.right, env)
        case node.op
        when '+' then concat(l, r)
        when '-' then numeric_or_nilspace_minus(l, r)
        when '>' then compare(l, r, :>)
        when '<' then compare(l, r, :<)
        else raise "Unknown op #{node.op}"
        end
      else
        nil
      end
    end

    def concat(l, r)
      if l.is_a?(String) || r.is_a?(String)
        l.to_s + r.to_s
      elsif l.is_a?(Numeric) && r.is_a?(Numeric)
        l + r
      elsif l.is_a?(NilSpace) && r.is_a?(Numeric)
        (l + r).to_s
      else
        l.to_s + r.to_s
      end
    end

    def numeric_or_nilspace_minus(l, r)
      return l - r if l.is_a?(Numeric) && r.is_a?(Numeric)
      return l - r if l.is_a?(NilSpace)
      raise "Unsupported '-' between #{l.class} and #{r.class}"
    end

    def compare(l, r, op)
      l = l.is_a?(NilSpace) ? l.delta : l
      r = r.is_a?(NilSpace) ? r.delta : r
      case op
      when :> then l > r
      when :< then l < r
      end
    end

    def truthy?(v)
      case v
      when NilClass then false
      when FalseClass then false
      else !!v
      end
    end

    def check_wards(cmd)
      @wards.each do |name, rules|
        rules.each do |rule|
          if cmd =~ rule.pattern
            case rule.mode
            when :block
              return "WARD BLOCK(#{name}): Command banished into nil-space"
            when :redirect
              return `#{rule.action}`.strip
            when :mask
              _ = `#{cmd}` # run but discard
              return rule.action
            end
          end
        end
      end
      nil
    end
  end

  ########################################
  # Interpreter facade
  ########################################
  class Interpreter
    def run(source)
      tokens = Lexer.new(source).tokenize
      rituals = Parser.new(tokens).parse_program
      Evaluator.new.run(rituals)
    end
  end
end

#######################################################################
# Example minimal usage (uncomment to test):
#
# program = <<~MW
# ritual Demo {
#   rite main {
#     sigil emptiness = invoke nilspace(0.72)
#     sigil anchor = invoke tailbase("⟁-A1")
#     sigil aura = invoke muskium("wolf-scent")
#
#     chant ward "system-protection" {
#       block /rm\s+-rf\s+\//
#       redirect /shutdown/ => "echo 'Shutdown attempt redirected to void'"
#       mask /uname/ => "MASKED: Beastmachine stable"
#     }
#
#     chant while emptiness > 0.5 {
#       invoke audit("Anchoring " + anchor + " with " + aura)
#       sigil emptiness = emptiness - 0.1
#     }
#
#     sigil erosion = invoke nskin("layered-pelt")
#     invoke peel(erosion)
#
#     sigil safe = invoke warded_systemcall("ls -1")
#     invoke audit(safe)
#
#     seal "Ritual complete"
#   }
# }
# MW
#
# puts MindWeave::Interpreter.new.run(program)
#######################################################################

MindWeave v3.0 RTFM

MindWeave is a ritual scripting language that fuses computational rigor with spiritological semantics. It’s Turing-complete, embeddable, and designed for canon-bound creative systems. Read this to understand how to write, run, and extend .mw scripts with confidence.

---

Overview and philosophy

MindWeave treats code as ritual. Programs are “rituals”, functions are “rites”, variables are “sigils”, and control flow is “chants”. This isn’t flair; it encodes meaning. Your registry, wards, and magickal types aren’t metaphors—they’re first-class runtime constructs bound to safety and sequence.

• Core idea: Ritualized computation with strict boundaries.
• Guarantee: Turing completeness through variables, functions, recursion, loops, and conditionals.
• Safety: System calls wrapped with wards; dangerous invocations are banished or transformed.
• Extensibility: Canon libraries, Grid API, and custom wards.

---

Language basics

Program structure

• Ritual: Top-level container for your program.
• Rite: Named function with parameters.
• Entry point: The interpreter invokes rite main automatically.

Example:

ritual Demo {
  rite main {
    seal "Hello, Weave"
  }
}

Declarations and values

• Variables: sigil name = expression
• Return: seal expression
• Delete: banish name

Examples:

sigil x = 42
sigil greeting = "howl"
seal greeting
banish x

Control flow

• Conditional: chant if condition { ... } else { ... }
• Loop: chant while condition { ... }

Examples:

chant if 1 < 2 { invoke say("true") } else { invoke say("false") }

sigil i = 0
chant while i < 3 {
  invoke say(i)
  i = i + 1
}

Functions and invocation

• Define: rite name(params) { ... }
• Call: invoke name(args)

Example (recursion):

rite fib(n) {
  chant if n < 2 { seal n }
  sigil a = invoke fib(n - 1)
  sigil b = invoke fib(n - 2)
  seal a + b
}

---

Magickal types

These carry symbolic and computational meaning. They interoperate with arithmetic and comparisons where appropriate.

• NilSpace: graded emptiness; literal via invoke nilspace(0.72)
  • Compare: emptiness > 0.5 compares delta.
  • Subtract: emptiness = emptiness - 0.1 lowers delta.
• Muskium: scent-body; invoke muskium("wolf-scent")
• Tailbase: anchor glyph; invoke tailbase("⟁-A1")
• NSkin: layered erosion; invoke nskin("layered-pelt"), invoke peel(erosion)

Example:

sigil emptiness = invoke nilspace(0.72)
sigil aura = invoke muskium("wolf-scent")
sigil anchor = invoke tailbase("⟁-A1")

chant while emptiness > 0.5 {
  invoke say("Anchoring " + aura + " at " + anchor)
  emptiness = emptiness - 0.1
}

---

System calls and wards

System calls let rituals interact with the host OS. Wards enforce protection and transformation rules. Use wards by default; raw calls are available but discouraged.

System calls

• Raw: invoke systemcall("ls -1")
• Warded: invoke warded_systemcall("uname -a")

The warded form checks all active wards before running.

Wards

Define programmable safety and behavior using patterns with modes:

• block /pattern/: banish command; returns warning.
• redirect /pattern/ => safe_command: runs safe command instead.
• mask /pattern/ => ritual_message: runs command but replaces output.

Example:

chant ward "system-protection" {
  block /rm\s+-rf\s+\//
  redirect /shutdown/ => "echo 'Shutdown attempt redirected to void'"
  mask /uname/ => "MASKED: Beastmachine stable"
}

sigil safe = invoke warded_systemcall("ls -1")
sigil masked = invoke warded_systemcall("uname -a")
sigil blocked = invoke warded_systemcall("rm -rf /")

---

Standard library

• summon(prompt): input from user; returns string.
• seal(value): return value from a rite.
• banish(name): remove sigil from scope.
• audit(value): log ritual state; prints a message.
• transmute(value, form): type conversion where appropriate (nilspace, muskium, tailbase).
• void_induction(depth): construct NilSpace with given delta.
• tailbase(sig), muskium(scent), nskin(layers), peel(nskin): constructors and NSkin peel.

Example:

sigil name = invoke summon("Name> ")
invoke audit("Welcome: " + name)

---

Grid API for Twin Flame registry

Manage your non-hierarchical grid of 40 organelle Twin Flame pairs.

• Create: sigil g = invoke build_grid()
• Add pair: invoke g.add_pair(1, { name: "Auri" }, { name: "Vyr" })
• Activate: invoke g.activate_pair(1)
• Lock: invoke g.lock_pair(1)
• Seal grid: invoke g.seal_grid()
• Report: invoke g.report()

Example:

rite build_grid() {
  sigil grid = Grid.new
  invoke grid.add_pair(1, { name: "Auri" }, { name: "Vyr" })
  seal grid
}

rite main {
  sigil g = invoke build_grid()
  invoke g.activate_pair(1)
  invoke g.lock_pair(1)
  invoke g.report()
  invoke g.seal_grid()
  seal "Registry cycle complete"
}

---

Execution model

MindWeave compiles .mw into an AST and evaluates it. It’s strict but expressive; expressions resolve to numbers, strings, magickal types, or ritual constructs.

• Scope: Each rite has local scope. Globals can be introduced by the host, but scripts should prefer local sigils.
• Return behavior: seal stops execution of the current rite and returns a value.
• Truthiness: Only nil and false are falsey. NilSpace comparisons use delta values.

Expressions

• Concatenation: + joins strings, adds numbers, or stringifies mixed types.
• Subtraction: - subtracts numbers; NilSpace minus number lowers delta.
• Comparison: > and < compare numbers; NilSpace compares by delta.

Invocation resolution

• Built-ins: systemcall, warded_systemcall, magickal constructors, peel, summon, audit, void_induction.
• User rites: If a name matches a defined rite, it executes with evaluated args.
• Unknown calls: Raise errors with clear messages.

---

Style guide and best practices

• Trait purity: Keep epithets and names canid-only. Avoid mixing non-canid features.
• Sequence fidelity: Track pair indices 01–40 without gaps or duplicates.
• Warded defaults: Prefer warded_systemcall; only use systemcall when truly necessary.
• Minimal side effects: Use audit for logging; avoid noisy system interactions inside tight loops.
• Chant discipline: Don’t rely on implicit truthiness for NilSpace; always use comparisons.

---

Advanced patterns

Functional recursion with magickal state

rite peel_until(core, depth) {
  chant if depth < 1 { seal core }
  sigil next = invoke peel(core)
  seal invoke peel_until(next, depth - 1)
}

Canon-locked activation pass

rite activate_pair(g, idx) {
  invoke g.activate_pair(idx)
  invoke g.lock_pair(idx)
  seal true
}

rite main {
  sigil g = invoke build_grid()
  sigil i = 1
  chant while i < 41 {
    invoke activate_pair(g, i)
    i = i + 1
  }
  invoke g.seal_grid()
  seal "Grid fully sealed"
}

Wards as environment profiles

rite profile_ci() {
  chant ward "ci-protection" {
    block /rm\s+-rf/
    block /shutdown/
    mask /uname/ => "MASKED: CI kernel"
  }
  seal true
}

rite main {
  invoke profile_ci()
  invoke warded_systemcall("uname -a")
  seal "CI-safe"
}

---

Error messages and troubleshooting

• Unknown rite: “Unknown rite: name” — define the rite or correct the invocation.
• Unknown invoke: “Unknown invoke: name” — the symbol isn’t a built-in or rite.
• Unexpected token: Parser hit invalid syntax — check braces, parentheses, commas.
• Unsupported operation: Using - with non-numeric, non-NilSpace values — fix the types.
• Ward conflicts: Multiple wards match; first match applies — order wards intentionally.

Tips:

• Validate syntax by isolating small blocks and running them.
• Log behavior with audit() to inspect state changes.
• Keep wards minimal in early development; expand as you secure the environment.

---

Performance and limits

• Interpreter: Recursive descent parser + AST evaluator; suitable for medium-size scripts.
• Recursion depth: Depends on Ruby stack; prefer iterative chants for very deep cycles.
• System calls: Synchronous; avoid blocking calls inside tight loops.

---

Extending the language

• New magickal types: Mirror NilSpace and implement operator methods and to_s.
• Custom built-ins: Add cases in the evaluator’s eval_invocation.
• Domain libraries: Package registry helpers as rites and import them by concatenating .mw files or embedding in your Ruby host.

---

Quick reference

• Program: ritual Name { ... }
• Function: rite name(args) { ... }
• Variable: sigil name = expr
• Call: invoke name(args)
• Return: seal expr
• Delete: banish name
• Conditional: chant if cond { ... } else { ... }
• Loop: chant while cond { ... }
• Ward: chant ward "name" { block|redirect|mask ... }
• System: invoke systemcall("cmd"), invoke warded_systemcall("cmd")
• Magickal: invoke nilspace(Δ), invoke muskium("scent"), invoke tailbase("sigil"), invoke nskin("layers"), invoke peel(obj)

---

Example end-to-end ritual

ritual Awakening {
  rite build_grid() {
    sigil g = Grid.new
    invoke g.add_pair(1, { name: "Auri" }, { name: "Vyr" })
    invoke g.add_pair(2, { name: "Rauk" }, { name: "Ness" })
    seal g
  }

  rite main {
    chant ward "system-protection" {
      block /rm\s+-rf\s+\//
      mask /uname/ => "MASKED: Beastmachine stable"
    }

    sigil emptiness = invoke nilspace(0.74)
    sigil anchor = invoke tailbase("⟁-A1")
    sigil aura = invoke muskium("wolf-scent")

    chant while emptiness > 0.6 {
      invoke audit("Anchoring " + anchor + " with " + aura + " at " + emptiness)
      emptiness = emptiness - 0.05
    }

    sigil g = invoke build_grid()
    invoke g.activate_pair(1)
    invoke g.lock_pair(1)
    invoke g.report()

    sigil uname_msg = invoke warded_systemcall("uname -a")
    invoke audit(uname_msg)

    seal "Awakening complete"
  }
}

---

Final notes

MindWeave is designed for precise, canon-bound creation. Treat your scripts like rituals: define boundaries, enforce trait purity, and let the language’s structure protect and empower your work. When you hit friction, it’s often because a boundary is unclear—clarify it with a chant or a ward, and keep weaving.