@zalom/plastic 1.0.0-alpha.1 → 1.0.0-alpha.11

package/scripts/hook-session-start

@@ -117,15 +117,23 @@ if File.exist?(projects_path)
   end
 end
 
+# --- Load PLASTIC.md conventions ---
+
+plastic_md_path = "#{store_root}/PLASTIC.md"
+plastic_md = File.exist?(plastic_md_path) ? File.read(plastic_md_path).strip : nil
+
 # --- Load deprecations ---
 
+dep_file = if plugin_root && !plugin_root.empty?
+  "#{plugin_root}/deprecations.yml"
+else
+  "#{store_root}/deprecations.yml"
+end
+
 deprecations = []
-if plugin_root && !plugin_root.empty?
-  dep_file = "#{plugin_root}/deprecations.yml"
-  if File.exist?(dep_file)
-    dep_data = YAML.safe_load(File.read(dep_file)) rescue {}
-    deprecations = dep_data["deprecations"] || []
-  end
+if File.exist?(dep_file)
+  dep_data = YAML.safe_load(File.read(dep_file)) rescue {}
+  deprecations = dep_data["deprecations"] || []
 end
 
 dismissed_json = `"#{read_config}" deprecations_dismissed`.strip
@@ -136,7 +144,10 @@ rescue
 end
 
 current_version = nil
-if plugin_root && !plugin_root.empty?
+version_file = "#{store_root}/VERSION"
+if File.exist?(version_file)
+  current_version = File.read(version_file).strip
+elsif plugin_root && !plugin_root.empty?
   plugin_json_path = "#{plugin_root}/.claude-plugin/plugin.json"
   if File.exist?(plugin_json_path)
     pj = JSON.parse(File.read(plugin_json_path)) rescue {}
@@ -150,18 +161,40 @@ active_deprecations = deprecations.select do |dep|
   !dismissed.include?(dep["id"])
 end
 
-# --- Early exit if nothing to show ---
+# --- Check for available updates (from previous session's check) ---
+
+update_notice = nil
+cache_file = "#{store_root}/.cache/update-check.json"
+if File.exist?(cache_file)
+  cache = JSON.parse(File.read(cache_file)) rescue {}
+  if cache["updateAvailable"]
+    update_notice = "Plastic update available: #{cache["current"]} -> #{cache["latest"]} — run /plastic:update"
+  end
+end
+
+# --- Early exit only if no PLASTIC.md ---
 
 all_active = active + project_active
 all_future = future + project_future
-exit 0 if all_active.empty? && stale.empty? && all_future.empty? && active_deprecations.empty?
+exit 0 unless plastic_md
 
 # --- Build context ---
 
 parts = []
 
+# Conventions always loaded first
+parts << plastic_md
+parts << "\n---\n"
+
 if current_project
-  parts << "PLASTIC — Global store | Project: #{current_project["slug"]} (#{current_project["path"]})\n"
+  slug = current_project["slug"]
+  banner = "Project: #{slug} | Store: ~/.plastic/projects/#{slug}/store/"
+  if project_active.any? && project_active.first =~ /\[([^\]]+)\].*store\/([\w-]+)\//
+    intent_name, dir_name = $1, $2
+    intent_id = dir_name.split("--").first
+    banner += "\nActive: [#{intent_id} — #{intent_name}] | Artifacts → store/#{dir_name}/"
+  end
+  parts << banner + "\n"
 else
   parts << "PLASTIC — Global store loaded from ~/.plastic/\n"
 end
@@ -215,6 +248,10 @@ if active_deprecations.any?
   end
 end
 
+if update_notice
+  parts.unshift("! #{update_notice}\n")
+end
+
 payload = {
   "hookSpecificOutput" => {
     "hookEventName" => "SessionStart",

package/scripts/install.rb

@@ -141,13 +141,19 @@ def distribute(mode)
   puts "  \u{1f4e6} #{mode == :update ? "Updating" : "Installing"} core files to #{PLASTIC_HOME}"
 
   FileUtils.mkdir_p(PLASTIC_HOME)
-  FileUtils.mkdir_p(File.join(PLASTIC_HOME, "scripts"))
+  FileUtils.mkdir_p(File.join(PLASTIC_HOME, "scripts", "lib"))
 
   core_files = {
     "PLASTIC.md" => "PLASTIC.md",
     "deprecations.yml" => "deprecations.yml",
     "scripts/folgezettel-id" => "scripts/folgezettel-id",
     "scripts/read-config" => "scripts/read-config",
+    "scripts/hook-session-start" => "scripts/hook-session-start",
+    "scripts/hook-continue" => "scripts/hook-continue",
+    "scripts/hook-future-intent-check" => "scripts/hook-future-intent-check",
+    "scripts/hook-gate-check" => "scripts/hook-gate-check",
+    "scripts/lib/bridge.rb" => "scripts/lib/bridge.rb",
+    "scripts/doctor.rb" => "scripts/doctor.rb",
   }
 
   core_files.each do |src, dest|
@@ -211,6 +217,31 @@ def bootstrap
   puts "  \u{2705} Store bootstrapped"
 end
 
+def bootstrap_project_store(slug)
+  project_dir = File.join(PLASTIC_HOME, "projects", slug)
+  store_dir = File.join(project_dir, "store")
+
+  FileUtils.mkdir_p(store_dir)
+
+  template = File.join(PACKAGE_ROOT, "templates", "project.yml")
+  dest = File.join(project_dir, "project.yml")
+  write_if_missing(dest, File.read(template)) if File.exist?(template)
+
+  write_if_missing(File.join(project_dir, "INDEX.md"), <<~MD)
+    # Index
+
+    ## Active
+
+    ## Future
+
+    ## Clusters
+
+    ## Abandoned
+
+    ## Completed
+  MD
+end
+
 # --- Agent adapters ---
 
 def install_for_agent(key, force)
@@ -239,7 +270,7 @@ def install_claude(config, force)
 
   installed = []
 
-  # Copy hooks
+  # Copy hooks, rewriting script paths for the installed location
   hook_source = File.join(PACKAGE_ROOT, "hooks")
   Dir.glob(File.join(hook_source, "*")).each do |f|
     next unless File.file?(f)
@@ -247,7 +278,9 @@ def install_claude(config, force)
     next if %w[hooks.json run-hook].include?(basename)
     dest_name = basename.start_with?("plastic-") ? basename : "plastic-#{basename}"
     dest = File.join(hooks_dir, dest_name)
-    FileUtils.cp(f, dest)
+    content = File.read(f)
+    content = content.gsub('$SCRIPT_DIR/../scripts/', '$HOME/.plastic/scripts/')
+    File.write(dest, content)
     FileUtils.chmod(0o755, dest)
     installed << dest
   end
@@ -261,7 +294,10 @@ def install_claude(config, force)
   File.write(version_file, "#{VERSION}\n")
   installed << version_file
 
-  # Merge hooks into settings.json
+  # Sync marketplace plugin so Claude Code discovers skills
+  sync_marketplace_plugin(config[:dir])
+
+  # Merge hooks + enabledPlugins into settings.json
   settings_path = File.join(config[:dir], "settings.json")
   merge_claude_hooks(settings_path)
 
@@ -300,46 +336,167 @@ def install_hermes(config, force)
   { agent: config[:name], success: true, files: installed.size }
 end
 
+# --- Marketplace plugin sync ---
+
+def sync_marketplace_plugin(claude_dir)
+  marketplace_dir = File.join(claude_dir, "plugins", "marketplaces", "plastic")
+  plugin_meta_dir = File.join(marketplace_dir, ".claude-plugin")
+
+  FileUtils.mkdir_p(plugin_meta_dir)
+
+  plugin_json = {
+    "name" => "plastic",
+    "description" => "Intent-driven state management for AI coding sessions. Neuroplasticity for your codebase.",
+    "version" => VERSION,
+    "author" => { "name" => "Zlatko Alomerovic", "email" => "zlatko.alomerovic@gmail.com" },
+    "homepage" => "https://github.com/zalom/plastic",
+    "repository" => "https://github.com/zalom/plastic",
+    "license" => "MIT",
+    "keywords" => %w[intent-driven state-management zettelkasten ai-agent]
+  }
+  write_json_atomic(File.join(plugin_meta_dir, "plugin.json"), plugin_json)
+
+  marketplace_json = {
+    "name" => "plastic",
+    "description" => "Marketplace for Plastic — intent-driven state management",
+    "owner" => { "name" => "Zlatko Alomerovic", "email" => "zlatko.alomerovic@gmail.com" },
+    "plugins" => [{
+      "name" => "plastic",
+      "description" => "Intent-driven state management for AI coding sessions",
+      "version" => VERSION,
+      "source" => "./",
+      "author" => { "name" => "Zlatko Alomerovic", "email" => "zlatko.alomerovic@gmail.com" }
+    }]
+  }
+  write_json_atomic(File.join(plugin_meta_dir, "marketplace.json"), marketplace_json)
+
+  # Sync skills
+  skills_source = File.join(PACKAGE_ROOT, "skills")
+  skills_dest = File.join(marketplace_dir, "skills")
+  if File.directory?(skills_source)
+    FileUtils.rm_rf(skills_dest)
+    copy_dir_recursive(skills_source, skills_dest)
+  end
+
+  # Sync agents
+  agents_source = File.join(PACKAGE_ROOT, "agents")
+  agents_dest = File.join(marketplace_dir, "agents")
+  if File.directory?(agents_source)
+    FileUtils.rm_rf(agents_dest)
+    copy_dir_recursive(agents_source, agents_dest)
+  end
+
+  # Write .claude/settings.json (permissions)
+  claude_settings_dir = File.join(marketplace_dir, ".claude")
+  FileUtils.mkdir_p(claude_settings_dir)
+  write_json_atomic(File.join(claude_settings_dir, "settings.json"), {
+    "permissions" => {
+      "allow" => [
+        "Bash(ruby *)",
+        "Bash(ls *)",
+        "Bash(find *)",
+        "Bash(git *)",
+        "Bash(mkdir *)",
+        "Bash(chmod *)",
+        "mcp__serena__*"
+      ]
+    }
+  })
+end
+
 # --- settings.json merge (read-modify-write, never clobber) ---
 
 def merge_claude_hooks(settings_path)
   settings = read_json_safe(settings_path) || {}
-  return if settings.nil? # unparseable — refuse to modify
+  return if settings.nil?
 
   hooks = settings["hooks"] ||= {}
   hook_dir = File.join(Dir.home, ".claude", "hooks")
 
+  purge_stale_plastic_hooks(hooks)
+
   plastic_hooks = {
-    "SessionStart" => [
-      { "type" => "command", "command" => "ruby #{hook_dir}/plastic-session-start", "statusMessage" => "Loading Plastic context..." },
-      { "type" => "command", "command" => "#{hook_dir}/plastic-check-update", "statusMessage" => "" },
-    ],
-    "PreCompact" => [
-      { "type" => "command", "command" => "ruby #{hook_dir}/plastic-savepoint", "statusMessage" => "Saving Plastic intent state..." },
-    ],
-    "PostToolUse" => [
-      { "matcher" => "Write|Edit", "type" => "command", "command" => "#{hook_dir}/plastic-gate-check", "statusMessage" => "Checking lifecycle gates..." },
-    ],
-    "UserPromptSubmit" => [
-      { "type" => "command", "command" => "#{hook_dir}/plastic-continue", "statusMessage" => "Checking for continue..." },
-      { "type" => "command", "command" => "#{hook_dir}/plastic-future-intent-check", "statusMessage" => "Checking future intents..." },
-    ],
-    "statusLine" => [
-      { "type" => "command", "command" => "#{hook_dir}/plastic-statusline" },
-    ],
+    "SessionStart" => {
+      "matcher" => "",
+      "hooks" => [
+        { "type" => "command", "command" => "#{hook_dir}/plastic-session-start", "statusMessage" => "Loading Plastic context..." },
+        { "type" => "command", "command" => "#{hook_dir}/plastic-check-update", "statusMessage" => "" },
+      ],
+    },
+    "PreCompact" => {
+      "matcher" => "",
+      "hooks" => [
+        { "type" => "command", "command" => "#{hook_dir}/plastic-savepoint", "statusMessage" => "Saving Plastic intent state..." },
+      ],
+    },
+    "PostToolUse" => {
+      "matcher" => "Write|Edit",
+      "hooks" => [
+        { "type" => "command", "command" => "#{hook_dir}/plastic-gate-check", "statusMessage" => "Checking lifecycle gates..." },
+      ],
+    },
+    "UserPromptSubmit" => {
+      "matcher" => "",
+      "hooks" => [
+        { "type" => "command", "command" => "#{hook_dir}/plastic-continue", "statusMessage" => "Checking for continue..." },
+        { "type" => "command", "command" => "#{hook_dir}/plastic-future-intent-check", "statusMessage" => "Checking future intents..." },
+      ],
+    },
   }
 
-  plastic_hooks.each do |event, entries|
+  plastic_hooks.each do |event, group|
     hooks[event] ||= []
-    entries.each do |entry|
-      already = hooks[event].any? { |h| h["command"] == entry["command"] }
-      hooks[event] << entry unless already
+    existing = hooks[event].find { |g| g.is_a?(Hash) && g["hooks"].is_a?(Array) && g["hooks"].any? { |h| h["command"].to_s.include?("plastic-") } }
+
+    if existing
+      existing["matcher"] = group["matcher"]
+      existing["hooks"] = group["hooks"]
+    else
+      hooks[event] << group
     end
   end
 
+  existing_status = settings["statusLine"]
+  if existing_status && !existing_status.dig("command").to_s.include?("plastic-")
+    cache_dir = File.join(PLASTIC_HOME, ".cache")
+    FileUtils.mkdir_p(cache_dir)
+    File.write(File.join(cache_dir, "original-statusline.json"), JSON.pretty_generate(existing_status))
+  end
+
+  settings["statusLine"] = { "type" => "command", "command" => "#{hook_dir}/plastic-statusline" }
+
+  # Register Plastic as an enabled plugin for skill discovery
+  plugins = settings["enabledPlugins"] ||= {}
+  plugins["plastic@plastic"] = true
+
+  # Register the marketplace source
+  marketplaces = settings["extraKnownMarketplaces"] ||= {}
+  marketplaces["plastic"] ||= { "source" => { "source" => "github", "repo" => "zalom/plastic" } }
+
   write_json_atomic(settings_path, settings)
 end
 
+def purge_stale_plastic_hooks(hooks)
+  plastic_cmd = ->(cmd) { cmd.to_s.include?("plastic-") }
+
+  hooks.delete("statusLine")
+
+  hooks.each do |event, groups|
+    next unless groups.is_a?(Array)
+
+    hooks[event] = groups.map do |group|
+      if group.is_a?(Hash) && group["hooks"].is_a?(Array)
+        group["hooks"].reject! { |h| plastic_cmd.call(h["command"]) }
+        group unless group["hooks"].empty?
+      elsif group.is_a?(Hash) && group["command"]
+        plastic_cmd.call(group["command"]) ? nil : group
+      else
+        group
+      end
+    end.compact
+  end
+end
+
 # --- Uninstall ---
 
 def handle_uninstall(agents)
@@ -384,7 +541,12 @@ def uninstall_agent(key, config)
 
   # Clean known directories
   dirs_to_clean = case key
-                  when "claude" then [File.join(config[:dir], "plastic"), File.join(config[:dir], "skills", "plastic")]
+                  when "claude"
+                    [
+                      File.join(config[:dir], "plastic"),
+                      File.join(config[:dir], "skills", "plastic"),
+                      File.join(config[:dir], "plugins", "marketplaces", "plastic"),
+                    ]
                   else [File.join(config[:dir], "skills", "plastic")]
                   end
 
@@ -403,11 +565,37 @@ def remove_claude_hooks(settings_path)
   settings = read_json_safe(settings_path)
   return unless settings && settings["hooks"]
 
-  settings["hooks"].each do |event, entries|
-    settings["hooks"][event] = entries.reject { |h| (h["command"] || "").include?("plastic-") }
+  settings["hooks"].each do |event, groups|
+    next unless groups.is_a?(Array)
+
+    settings["hooks"][event] = groups.map do |group|
+      if group.is_a?(Hash) && group["hooks"].is_a?(Array)
+        group["hooks"].reject! { |h| h["command"].to_s.include?("plastic-") }
+        group unless group["hooks"].empty?
+      elsif group.is_a?(Hash) && group["command"]
+        group["command"].to_s.include?("plastic-") ? nil : group
+      else
+        group
+      end
+    end.compact
   end
-  settings["hooks"].delete_if { |_, v| v.empty? }
+
+  settings["hooks"].delete_if { |_, v| v.is_a?(Array) && v.empty? }
   settings.delete("hooks") if settings["hooks"]&.empty?
+  if settings.dig("statusLine", "command").to_s.include?("plastic-")
+    settings.delete("statusLine")
+    original_path = File.join(PLASTIC_HOME, ".cache", "original-statusline.json")
+    if File.exist?(original_path)
+      original = JSON.parse(File.read(original_path)) rescue nil
+      settings["statusLine"] = original if original
+    end
+  end
+
+  # Remove from enabledPlugins
+  if settings["enabledPlugins"]
+    settings["enabledPlugins"].delete("plastic@plastic")
+    settings.delete("enabledPlugins") if settings["enabledPlugins"].empty?
+  end
 
   write_json_atomic(settings_path, settings)
 end

package/scripts/lib/bridge.rb

@@ -2,6 +2,7 @@
 # encoding: UTF-8
 
 require "json"
+require "yaml"
 require "fileutils"
 require "tempfile"
 
@@ -136,4 +137,37 @@ module Bridge
 
     nil # no gate violation
   end
+
+  PROJECT_CONFIG_DEFAULTS = {
+    "governing_docs" => ["AGENTS.md"],
+    "release" => {
+      "on_complete" => "commit",
+    },
+  }.freeze
+
+  def self.read_project_config(slug)
+    path = File.join(Dir.home, ".plastic", "projects", slug, "project.yml")
+    config = if File.exist?(path)
+               YAML.safe_load(File.read(path)) || {}
+             else
+               {}
+             end
+
+    deep_merge(PROJECT_CONFIG_DEFAULTS, config)
+  rescue => e
+    $stderr.puts "Warning: failed to read project config for #{slug}: #{e.message}"
+    PROJECT_CONFIG_DEFAULTS.dup
+  end
+
+  def self.deep_merge(base, overlay)
+    result = base.dup
+    overlay.each do |key, value|
+      if value.is_a?(Hash) && result[key].is_a?(Hash)
+        result[key] = deep_merge(result[key], value)
+      else
+        result[key] = value
+      end
+    end
+    result
+  end
 end

package/skills/_active-intent-gate.md

@@ -0,0 +1,26 @@
+## Active Intent Gate
+
+Before proceeding, resolve the active intent:
+
+1. **Detect store:**
+   - Read `~/.plastic/projects.yml`
+   - Match CWD against registered project paths
+   - If match → project store at `~/.plastic/projects/{slug}/store/`
+   - If no match → global store at `~/.plastic/store/`
+
+2. **Find active intent:**
+   - Read `INDEX.md` from the detected store
+   - Look under `## Active` for intent entries
+   - If exactly one active intent → use it
+   - If multiple active intents → ask user which one
+   - If no active intent → refuse: "No active intent. Create one first with /plastic:creating-intent"
+
+3. **Resolve paths:**
+   - Intent directory: `{store}/store/{id}--{slug}/`
+   - Spec: `{intent_dir}/spec.md`
+   - Plan: `{intent_dir}/plan.md`
+   - Checklist: `{intent_dir}/checklist.md`
+   - Resources: `{intent_dir}/resources/`
+   - Outcome: `{intent_dir}/outcome.md`
+
+All lifecycle artifacts MUST be written to the intent directory. Never write to `docs/superpowers/specs/`, `docs/superpowers/plans/`, or any other external path.

package/skills/auto/SKILL.md

@@ -111,12 +111,26 @@ During initial project creation, all decisions are non-destructive by definition
 1. Verify all checklist items are checked
 2. Write `outcome.md` with detailed results
 3. Write `## Outcome` summary in the intent file (1-2 sentences)
-4. Review `## Insights` for observations that should spawn future intents. If any:
+4. **Release (if configured)**
+   1. Detect project — match CWD against paths in `~/.plastic/projects.yml` to find the project slug. If no match, skip to step 5 (default commit-only behavior).
+   2. Read `~/.plastic/projects/{slug}/project.yml`. If the file doesn't exist or has no `release` key, skip to step 5.
+   3. Based on `release.on_complete`:
+      - `commit` — git add + commit (same as default, proceed to step 5)
+      - `commit_and_push` — git add + commit + push
+      - `manual` — skip auto-commit, notify user: "Release configured as manual — commit when ready."
+   4. If `release.verify` is set, run the verify command (e.g. `bundle exec rake test`):
+      - **Exit 0 (green):** proceed to sub-step 5
+      - **Non-zero (red):** check `release.on_red`:
+        - `fix_and_retry` — attempt to fix the failure, re-run verify (max 2 retries)
+        - `stop` — write `savepoint.md` with current state, notify user: "Verify failed — savepoint written.", **STOP**
+        - `manual` — notify user: "Verify failed: [summary]. Resolve manually."
+   5. If `release.on_green` has items, invoke `plastic:releasing` to handle them (tag, changelog, publish, etc.). Do NOT duplicate release logic — delegate entirely.
+5. Review `## Insights` for observations that should spawn future intents. If any:
    - Create them (using `plastic:creating-intent` conventions)
    - Update `chain` in the current intent's frontmatter
-5. Move intent from `## Active` to `## Completed` in INDEX.md (with today's date)
-6. Auto-commit: `cd <store-root> && git add . && git commit -m "feat: deliver intent <ID> — <name>"`
-7. Notify user: "Intent [ID] — [name] delivered. [1-2 sentence summary]. See outcome.md for details."
+6. Move intent from `## Active` to `## Completed` in INDEX.md (with today's date)
+7. Auto-commit: `cd <store-root> && git add . && git commit -m "feat: deliver intent <ID> — <name>"`
+8. Notify user: "Intent [ID] — [name] delivered. [1-2 sentence summary]. See outcome.md for details."
 
 ## Error Handling
 
@@ -125,3 +139,7 @@ If the agent gets stuck (can't resolve a gap, dependency is missing, tests fail
 2. Write `savepoint.md` with current state
 3. Notify user: "Blocked on intent [ID] — [name]: [description]. Savepoint written."
 4. **STOP.** Do not attempt workarounds that could leave the project in a broken state.
+
+## References
+
+- Read `references/agent-architecture.md` for the full agent hierarchy (Main Orchestrator, Project Orchestrators, coordination loop) when dispatching agents or understanding autonomous delivery scope

package/skills/auto/references/agent-architecture.md

@@ -0,0 +1,60 @@
+# Agent Architecture
+
+## Main Orchestrator
+
+The Main Orchestrator manages the global store (Main Knowledge Base). It:
+- Recognizes, creates, updates, and groups intents
+- Spawns Project Orchestrators for registered projects
+- Receives contributions back from Project Orchestrators
+- Is the only agent that runs in a loop (continuous Build→Observe→Repeat)
+
+## Project Orchestrators
+
+Project Orchestrators manage project stores (Project Knowledge Bases). They:
+- Care about intents and execution within their project
+- Spawn teams to develop and execute intents
+- Contribute back to the Main Orchestrator when new intents are born
+  that could enrich the Main Knowledge Base
+
+Rules:
+- 1 Main Orchestrator : 1 Global Store (`~/.plastic/`)
+- 1 Main Orchestrator : N Project Orchestrators
+- 1 Project Orchestrator : 1 Project Store
+- 1 Agent : 1 Intent (exclusive assignment)
+- 1 Agent : N Sub-agents (for parallel Actions within an intent)
+
+## Two Modes
+
+- **Human-driven:** Human chats with Main Orchestrator, creates intents,
+  brainstorms, then Main Orchestrator dispatches Project Orchestrators and
+  Agents for execution.
+- **Autonomous:** Human gives Main Orchestrator a starting intent with defined
+  outcomes. Main Orchestrator runs the full cycle — Agents do the lifecycle
+  (What→Why→How→Exec), Main Orchestrator reviews Insights, spawns next intents,
+  dispatches again.
+
+## Autonomous Delivery
+
+Human owns What and Why for human-initiated intents. Agent assists (research,
+exploration) but human drives until handoff. When Why is complete — or human
+triggers `plastic:auto` — the agent takes over How and Exec autonomously.
+
+- **Safe-by-default:** Agent always prefers non-destructive routes (rename vs
+  delete, additive migrations, backups before changes). Destructive actions on
+  existing projects require human approval unless `--skip-permissions` is set.
+- **One agent per intent.** Agent follows the full W→W→H→E lifecycle.
+- **Notification only on:** finish or hard stop (blocked on destructive action,
+  unresolvable error). No progress reports — `## Insights` tracks everything.
+- **Greenfield autonomy:** During initial project creation, all decisions are
+  non-destructive (nothing to destroy). Agent has full autonomy for greenfield choices.
+- **Autonomous decisions** are logged in `## Insights` with `(autonomous)` marker.
+
+## Coordinator Loop
+
+When "work on Project X":
+1. Read `projects.yml` → find project path
+2. Load global config (defaults)
+3. Load project config (overrides)
+4. Load global INDEX.md → find hub intents tagged `project-<name>`
+5. Load project INDEX.md → tactical intents
+6. Coordinator has full picture, dispatches Agent teams