chore: populate SCM files with project metadata

Updated all 6 SCM files in .machine_readable/ with comprehensive content:
- STATE.scm: Project status, components, milestones, blockers
- META.scm: Architecture decisions, development practices, design rationale
- ECOSYSTEM.scm: Position in ecosystem, related projects
- AGENTIC.scm: AI agent patterns, language-specific syntax
- NEUROSYM.scm: Neurosymbolic integration configuration
- PLAYBOOK.scm: Operational runbook, build/test/deploy procedures

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: Jonathan D.A. Jewell

.machine_readable/AGENTIC.scm

@@ -2,15 +2,43 @@
 ;; AGENTIC.scm - AI agent interaction patterns for wokelang
 
 (define agentic-config
-  `((version . "1.0.0")
+  \`((version . "1.0.0")
     (claude-code
       ((model . "claude-opus-4-5-20251101")
        (tools . ("read" "edit" "bash" "grep" "glob"))
        (permissions . "read-all")))
     (patterns
-      ((code-review . "thorough")
-       (refactoring . "conservative")
-       (testing . "comprehensive")))
+      ((code-review
+         (style . "thorough")
+         (focus . ("consent-safety" "human-readability" "unit-correctness")))
+       (refactoring
+         (style . "conservative")
+         (preserve . ("consent-gates" "gratitude-blocks" "emote-annotations")))
+       (testing
+         (style . "comprehensive")
+         (coverage . ("parser" "interpreter" "consent-system")))))
+    (language-specific
+      ((syntax-patterns
+         (function-def . "to NAME(PARAMS) { ... }")
+         (variable . "remember NAME = VALUE")
+         (conditional . "when COND { ... } otherwise { ... }")
+         (loop . "repeat N times { ... }")
+         (consent . "only if okay MESSAGE { ... }")
+         (gratitude . "thanks to { CONTRIBUTOR -> CONTRIBUTION }")
+         (units . "VALUE measured in UNIT")
+         (emote . "@feeling(param=value) STATEMENT"))
+       (error-handling
+         (try-block . "attempt safely { ... } or reassure MESSAGE")
+         (error-throw . "complain MESSAGE"))
+       (concurrency
+         (worker . "worker NAME { ... }")
+         (spawn . "spawn worker NAME")
+         (message . "send VALUE to TARGET"))))
     (constraints
-      ((languages . ())
-       (banned . ("typescript" "go" "python" "makefile"))))))
+      ((languages . ("rust" "ocaml" "wasm"))
+       (banned . ("typescript" "go" "python" "makefile"))
+       (preferred-tools
+         (build . "just")
+         (format-rust . "cargo fmt")
+         (format-ocaml . "ocamlformat")
+         (lint-rust . "cargo clippy"))))))

.machine_readable/ECOSYSTEM.scm

@@ -5,16 +5,58 @@
 (ecosystem
   (version "1.0")
   (name "wokelang")
-  (type "")
-  (purpose "")
+  (type "programming-language")
+  (purpose "Human-centered, consent-driven programming with built-in ethics")
 
   (position-in-ecosystem
-    (category "")
-    (subcategory "")
-    (unique-value ()))
+    (category "programming-languages")
+    (subcategory "domain-specific-languages")
+    (unique-value
+      "Consent gates for sensitive operations"
+      "Built-in gratitude/attribution system"
+      "Units of measure as first-class citizens"
+      "Emotional annotations for code context"
+      "Human-readable English-like syntax"))
 
-  (related-projects ())
+  (related-projects
+    (project "affinescript"
+      (relationship "sibling-standard")
+      (description "OCaml-based language compiler framework"))
+    (project "palimpsest-licence"
+      (relationship "philosophical-foundation")
+      (description "Ethical licensing framework that WokeLang adopts"))
+    (project "python"
+      (relationship "inspiration")
+      (description "Readability and accessibility influence"))
+    (project "rust"
+      (relationship "inspiration")
+      (description "Safety-first design and performance target"))
+    (project "elm"
+      (relationship "inspiration")
+      (description "User-friendly error messages"))
+    (project "gleam"
+      (relationship "inspiration")
+      (description "Friendly syntax and approachability"))
+    (project "roc"
+      (relationship "inspiration")
+      (description "Fast, friendly, functional design"))
+    (project "januskey"
+      (relationship "potential-consumer")
+      (description "Could use WokeLang for consent-aware scripting"))
+    (project "bunsenite"
+      (relationship "potential-consumer")
+      (description "Configuration language integration")))
 
-  (what-this-is ())
+  (what-this-is
+    "A programming language prioritizing human collaboration and safety"
+    "An ethical programming framework with consent-based control flow"
+    "A tool for writing self-documenting, attribution-aware code"
+    "A language with built-in dimensional analysis"
+    "A practical experiment in human-centered language design")
 
-  (what-this-is-not ()))
+  (what-this-is-not
+    "A general-purpose systems programming language"
+    "A replacement for Rust, OCaml, or production languages"
+    "A toy language or joke project"
+    "An AI-only or machine-generated language"
+    "A language focused on maximum performance"))

.machine_readable/META.scm

@@ -3,15 +3,76 @@
 ;; Media-Type: application/meta+scheme
 
 (meta
-  (architecture-decisions ())
+  (architecture-decisions
+    (adr-001
+      (title "Dual Implementation Strategy")
+      (status "accepted")
+      (date "2024-10")
+      (context "Need both rapid prototyping and production performance")
+      (decision "Use OCaml for language theory, Rust for production runtime")
+      (consequences
+        "Faster iteration on language design"
+        "Production-grade performance"
+        "Requires maintaining two codebases"))
+    (adr-002
+      (title "Consent-First Design")
+      (status "accepted")
+      (date "2024-10")
+      (context "Sensitive operations should require explicit permission")
+      (decision "Implement 'only if okay' gates for sensitive operations")
+      (consequences
+        "Safer by default"
+        "Self-documenting dangerous code paths"
+        "Slight increase in verbosity"))
+    (adr-003
+      (title "Human-Readable Syntax")
+      (status "accepted")
+      (date "2024-10")
+      (context "Code should be readable by non-programmers")
+      (decision "Use English-like keywords: to, give back, remember, when")
+      (consequences
+        "Lower barrier to entry"
+        "More inclusive programming"
+        "Slightly longer code"))
+    (adr-004
+      (title "Units of Measure as First-Class")
+      (status "accepted")
+      (date "2024-11")
+      (context "Unit-related bugs are common and dangerous")
+      (decision "Add 'measured in' syntax for compile-time unit checking")
+      (consequences
+        "Prevents NASA-style unit bugs"
+        "Self-documenting calculations"
+        "Requires dimensional analysis system")))
 
   (development-practices
-    (code-style ())
+    (code-style
+      (rust "cargo fmt and clippy")
+      (ocaml "ocamlformat")
+      (documentation "AsciiDoc preferred"))
     (security
-      (principle "Defense in depth"))
-    (testing ())
+      (principle "Defense in depth")
+      (consent-model "Explicit opt-in for sensitive operations")
+      (capability-system "Fine-grained permission control"))
+    (testing
+      (unit "Per-component tests in tests/")
+      (integration "End-to-end language tests")
+      (fuzzing "Property-based testing for parser"))
     (versioning "SemVer")
-    (documentation "AsciiDoc")
-    (branching "main for stable"))
+    (documentation "AsciiDoc for docs, docstrings for code")
+    (branching "main for stable, feature branches for development"))
 
-  (design-rationale ()))
+  (design-rationale
+    (why-consent-gates
+      "Sensitive operations like file I/O, network access, and data deletion "
+      "should require explicit permission. This prevents accidental damage "
+      "and makes dangerous code paths visible.")
+    (why-gratitude-blocks
+      "Attribution is often lost in codebases. The 'thanks to' syntax makes "
+      "it easy to acknowledge contributors inline where their work is used.")
+    (why-emote-annotations
+      "Code carries emotional context. A fix made under pressure differs from "
+      "one made thoughtfully. @emote tags capture this for future readers.")
+    (why-units-of-measure
+      "The Mars Climate Orbiter was lost due to a unit conversion error. "
+      "Compile-time dimensional analysis prevents these catastrophic bugs.")))

.machine_readable/NEUROSYM.scm

@@ -2,12 +2,30 @@
 ;; NEUROSYM.scm - Neurosymbolic integration config for wokelang
 
 (define neurosym-config
-  `((version . "1.0.0")
+  \`((version . "1.0.0")
     (symbolic-layer
       ((type . "scheme")
        (reasoning . "deductive")
-       (verification . "formal")))
+       (verification . "formal")
+       (grammar . "EBNF in docs/grammar.ebnf")
+       (type-system . "hindley-milner-inspired")))
     (neural-layer
       ((embeddings . false)
-       (fine-tuning . false)))
-    (integration . ())))
+       (fine-tuning . false)
+       (llm-integration
+         (code-generation . "claude-opus-4-5")
+         (code-review . "claude-opus-4-5")
+         (documentation . "claude-opus-4-5"))))
+    (integration
+      ((consent-validation
+         (approach . "symbolic-first")
+         (description . "Consent gates are checked symbolically at compile time"))
+       (unit-checking
+         (approach . "symbolic")
+         (description . "Dimensional analysis via type system"))
+       (error-messages
+         (approach . "neural-enhanced")
+         (description . "LLM can suggest fixes for common errors"))
+       (documentation-gen
+         (approach . "neural")
+         (description . "Generate docs from code using LLM"))))))

.machine_readable/PLAYBOOK.scm

@@ -2,12 +2,48 @@
 ;; PLAYBOOK.scm - Operational runbook for wokelang
 
 (define playbook
-  `((version . "1.0.0")
+  \`((version . "1.0.0")
     (procedures
-      ((deploy . (("build" . "just build")
-                  ("test" . "just test")
-                  ("release" . "just release")))
-       (rollback . ())
-       (debug . ())))
-    (alerts . ())
-    (contacts . ())))
+      ((build
+         ((rust . "cargo build --release")
+          (ocaml . "dune build")
+          (wasm . "wasm-pack build --target web")))
+       (test
+         ((rust . "cargo test")
+          (ocaml . "dune test")
+          (all . "just test")))
+       (format
+         ((rust . "cargo fmt")
+          (ocaml . "dune fmt")))
+       (lint
+         ((rust . "cargo clippy -- -D warnings")
+          (ocaml . "dune build @check")))
+       (release
+         ((steps
+            ("Bump version in Cargo.toml"
+             "Update CHANGELOG"
+             "Tag release: git tag vX.Y.Z"
+             "Build release: cargo build --release"
+             "Create GitHub release"))))
+       (deploy
+         ((wasm . "Deploy to CDN or npm")
+          (binary . "Publish to crates.io")))
+       (rollback
+         ((steps
+            ("Identify failing version"
+             "Revert to previous tag"
+             "Redeploy previous version"))))
+       (debug
+         ((repl . "cargo run -- repl")
+          (verbose . "RUST_LOG=debug cargo run")
+          (trace . "RUST_BACKTRACE=1 cargo run")))))
+    (alerts
+      ((ci-failure
+         (channel . "github-actions")
+         (action . "Review PR checks"))
+       (security-advisory
+         (channel . "dependabot")
+         (action . "Review and update dependencies"))))
+    (contacts
+      ((maintainer . "hyperpolymath")
+       (repo . "github.com/hyperpolymath/wokelang")))))

.machine_readable/STATE.scm

@@ -4,36 +4,59 @@
 
 (state
   (metadata
-    (version "0.0.1")
+    (version "0.1.0")
     (schema-version "1.0")
     (created "2026-01-03")
-    (updated "2026-01-03")
+    (updated "2026-01-04")
     (project "wokelang")
     (repo "github.com/hyperpolymath/wokelang"))
 
   (project-context
     (name "wokelang")
-    (tagline "")
-    (tech-stack ()))
+    (tagline "A human-centered, consent-driven programming language")
+    (tech-stack
+      ("Rust" "Primary implementation")
+      ("OCaml" "Core language theory")
+      ("WASM" "Browser/portable target")))
 
   (current-position
-    (phase "initial")
-    (overall-completion 0)
-    (components ())
-    (working-features ()))
+    (phase "foundation-complete")
+    (overall-completion 25)
+    (components
+      (lexer (status "complete") (completion 100))
+      (parser (status "complete") (completion 100))
+      (ast (status "complete") (completion 100))
+      (interpreter (status "complete") (completion 100))
+      (repl (status "complete") (completion 100))
+      (vm (status "in-progress") (completion 40))
+      (typechecker (status "planned") (completion 10))
+      (stdlib (status "in-progress") (completion 30))
+      (security (status "in-progress") (completion 50)))
+    (working-features
+      "to/give back functions"
+      "remember variables"
+      "when/otherwise conditionals"
+      "repeat...times loops"
+      "only if okay consent gates"
+      "thanks to gratitude blocks"
+      "measured in units"
+      "@emote annotations"))
 
   (route-to-mvp
-    (milestones ()))
+    (milestones
+      (phase-2 "Language Completeness" (target "Q1 2026"))
+      (phase-3 "Concurrency & Safety" (target "Q2 2026"))
+      (phase-4 "Standard Library" (target "Q3 2026"))
+      (phase-5 "Compiler & Performance" (target "Q4 2026"))))
 
   (blockers-and-issues
-    (critical)
-    (high)
-    (medium)
-    (low))
+    (high "Type system design not finalized")
+    (medium "Worker implementation incomplete"))
 
   (critical-next-actions
-    (immediate)
-    (this-week)
-    (this-month))
+    (immediate "Complete bytecode VM" "Add unit tests")
+    (this-week "Implement type inference")
+    (this-month "Complete Phase 2"))
 
-  (session-history ()))
+  (session-history
+    (session "2026-01-04" "Updated SCM files")))