textus 0.10.5 → 0.14.0

data/lib/textus/entry/yaml.rb

@@ -40,6 +40,65 @@ module Textus
       end
 
       def self.extensions = [".yaml", ".yml"]
+
+      def self.nested_glob = "**/*.{yaml,yml}"
+
+      def self.serialize_for_put(meta:, body:, content:, path:)
+        raise UsageError.new("put for yaml requires content: or body:") if content.nil? && (body.nil? || body.to_s.empty?)
+
+        if content.nil?
+          begin
+            parsed = parse(body.to_s, path: path)
+          rescue BadFrontmatter => e
+            raise BadContent.new(path, "bad_content: #{e.message}")
+          end
+          [body.to_s, parsed["_meta"], body.to_s, parsed["content"]]
+        else
+          bytes = serialize(meta: meta, body: "", content: content)
+          [bytes, meta, bytes, content]
+        end
+      end
+
+      # Mutating filesystem op; returns true if a write happened.
+      def self.rewrite_name(path, basename) # rubocop:disable Naming/PredicateMethod
+        raw = File.binread(path)
+        parsed = parse(raw, path: path)
+        meta = parsed["_meta"]
+        return false unless meta.is_a?(Hash) && meta["name"].is_a?(String) && meta["name"] != basename
+
+        new_meta = meta.merge("name" => basename)
+        File.binwrite(path, serialize(meta: new_meta, body: "", content: parsed["content"]))
+        true
+      end
+
+      def self.enforce_name_match!(path, meta)
+        return unless meta.is_a?(Hash) && meta["name"]
+
+        ext = extensions.first
+        basename = File.basename(path, ext)
+        return if meta["name"] == basename
+
+        raise BadFrontmatter.new(path, "name '#{meta["name"]}' does not match basename '#{basename}'")
+      end
+
+      def self.inject_uid(meta, content, existing_uid)
+        m = meta.is_a?(Hash) ? meta.dup : {}
+        m["uid"] = existing_uid || Textus::Store.mint_uid unless m["uid"].is_a?(String) && !m["uid"].empty?
+        [m, content]
+      end
+
+      def self.validate_path_extension(path, nested)
+        ext = File.extname(path)
+        if nested
+          return if ext == ""
+
+          raise UsageError.new("nested yaml path must not have an extension")
+        end
+
+        return if [".yaml", ".yml"].include?(ext)
+
+        raise UsageError.new("yaml format requires '.yaml' or '.yml' path (got #{ext.inspect})")
+      end
     end
   end
 end

data/lib/textus/entry.rb

@@ -10,10 +10,26 @@ module Textus
       "text" => Text,
     }.freeze
 
+    EXT_TO_FORMAT = {
+      ".md" => "markdown",
+      ".json" => "json",
+      ".yaml" => "yaml",
+      ".yml" => "yaml",
+      ".txt" => "text",
+    }.freeze
+
     def self.for_format(format)
       STRATEGIES.fetch(format.to_s) { raise UsageError.new("unknown entry format: #{format.inspect}") }
     end
 
+    def self.infer_from_extension(ext)
+      EXT_TO_FORMAT[ext]
+    end
+
+    def self.formats
+      EXT_TO_FORMAT.values.uniq
+    end
+
     def self.parse(raw, path: nil, format: "markdown")
       for_format(format).parse(raw, path: path)
     end

data/lib/textus/envelope.rb

@@ -1,30 +1,60 @@
 # frozen_string_literal: true
 
 module Textus
-  module Envelope
+  Envelope = Data.define(
+    :protocol, :key, :zone, :owner, :path, :format,
+    :uid, :etag, :schema_ref, :meta, :body, :content, :freshness
+  ) do
     # rubocop:disable Metrics/ParameterLists
-    def self.build(key:, mentry:, path:, meta:, body:, etag:, content: nil)
+    def self.build(key:, mentry:, path:, meta:, body:, etag:, content: nil, freshness: nil)
       # rubocop:enable Metrics/ParameterLists
-      env = {
-        "protocol" => PROTOCOL,
+      new(
+        protocol: Textus::PROTOCOL,
+        key: key,
+        zone: mentry.zone,
+        owner: mentry.owner,
+        path: path,
+        format: mentry.format,
+        uid: extract_uid(meta),
+        etag: etag,
+        schema_ref: mentry.schema,
+        meta: meta,
+        body: body,
+        content: content,
+        freshness: freshness,
+      )
+    end
+
+    def self.extract_uid(meta)
+      v = meta.is_a?(Hash) ? meta["uid"] : nil
+      v.is_a?(String) ? v : nil
+    end
+
+    def to_h_for_wire
+      h = {
+        "protocol" => protocol,
         "key" => key,
-        "zone" => mentry.zone,
-        "owner" => mentry.owner,
+        "zone" => zone,
+        "owner" => owner,
         "path" => path,
-        "format" => mentry.format,
+        "format" => format,
         "_meta" => meta,
         "body" => body,
         "etag" => etag,
-        "schema_ref" => mentry.schema,
-        "uid" => extract_uid(meta),
+        "schema_ref" => schema_ref,
+        "uid" => uid,
       }
-      env["content"] = content unless content.nil?
-      env
+      h["content"] = content unless content.nil?
+      freshness.each { |k, v| h[k.to_s] = v } if freshness.is_a?(Hash)
+      h
     end
 
-    def self.extract_uid(meta)
-      v = meta.is_a?(Hash) ? meta["uid"] : nil
-      v.is_a?(String) ? v : nil
+    def stale?
+      freshness.is_a?(Hash) && (freshness["stale"] == true || freshness[:stale] == true)
+    end
+
+    def refreshing?
+      freshness.is_a?(Hash) && (freshness["refreshing"] == true || freshness[:refreshing] == true)
     end
   end
 end

data/lib/textus/errors.rb

@@ -34,7 +34,7 @@ module Textus
       msg += "; did you mean: #{@suggestions.join(", ")}" unless @suggestions.empty?
       hint =
         if @suggestions.empty?
-          "run 'textus list --format=json' to see all keys"
+          "run 'textus list --output=json' to see all keys"
         else
           "did you mean: #{@suggestions.join(", ")}"
         end
@@ -61,6 +61,12 @@ module Textus
     end
   end
 
+  class BadManifest < Error
+    def initialize(m, hint: nil)
+      super("bad_manifest", m, hint: hint)
+    end
+  end
+
   class BadContent < Error
     def initialize(path, m)
       super(
@@ -89,7 +95,7 @@ module Textus
         if writers && !writers.empty?
           writers.join(", ")
         else
-          "the role(s) listed in the manifest 'writable_by:'"
+          "the role(s) listed in the manifest 'write_policy:'"
         end
       details = { "key" => k, "zone" => z }
       details["writers"] = writers if writers
@@ -121,11 +127,12 @@ module Textus
   end
 
   class InvalidRole < Error
-    def initialize(r)
+    def initialize(r, message: nil)
       super(
-        "invalid_role", "role '#{r}' is not declared in any zone",
+        "invalid_role",
+        message || "role '#{r}' is not declared in any zone",
         details: { "role" => r },
-        hint: "valid roles are declared in .textus/manifest.yaml under zones[].writable_by",
+        hint: message ? nil : "valid roles are declared in .textus/manifest.yaml under zones[].write_policy",
       )
     end
   end
@@ -165,4 +172,16 @@ module Textus
   class ProposalError < Error
     def initialize(m) = super("proposal_error", m)
   end
+
+  class FlagRenamed < Error
+    def initialize(old_flag, new_flag)
+      super(
+        "flag_renamed",
+        "#{old_flag} was renamed in textus/3 — use #{new_flag}",
+        details: { "old" => old_flag, "new" => new_flag },
+        hint: "Use #{new_flag} instead.",
+        exit_code: 2,
+      )
+    end
+  end
 end

data/lib/textus/hooks/builtin.rb

@@ -8,21 +8,21 @@ module Textus
     module Builtin
       # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       def self.register_all
-        Textus.hook(:intake, :json) do |store:, config:, args:|
+        Textus.on(:resolve_intake, :json) do |store:, config:, args:|
           _ = store
           _ = args
           data = JSON.parse(config["bytes"].to_s)
           { _meta: {}, body: YAML.dump(data) }
         end
 
-        Textus.hook(:intake, :csv) do |store:, config:, args:|
+        Textus.on(:resolve_intake, :csv) do |store:, config:, args:|
           _ = store
           _ = args
           rows = CSV.parse(config["bytes"].to_s, headers: true).map(&:to_h)
           { _meta: {}, body: YAML.dump(rows) }
         end
 
-        Textus.hook(:intake, :"markdown-links") do |store:, config:, args:|
+        Textus.on(:resolve_intake, :"markdown-links") do |store:, config:, args:|
           _ = store
           _ = args
           links = config["bytes"].to_s.scan(%r{\[([^\]]+)\]\((https?://[^)\s]+)\)}).map do |text, href|
@@ -31,7 +31,7 @@ module Textus
           { _meta: {}, body: YAML.dump(links) }
         end
 
-        Textus.hook(:intake, :"ical-events") do |store:, config:, args:|
+        Textus.on(:resolve_intake, :"ical-events") do |store:, config:, args:|
           _ = store
           _ = args
           events = []
@@ -50,7 +50,7 @@ module Textus
           { _meta: {}, body: YAML.dump(events) }
         end
 
-        Textus.hook(:intake, :rss) do |store:, config:, args:|
+        Textus.on(:resolve_intake, :rss) do |store:, config:, args:|
           _ = store
           _ = args
           doc = REXML::Document.new(config["bytes"].to_s)

data/lib/textus/hooks/dispatcher.rb

@@ -35,7 +35,7 @@ module Textus
         extras["target_key"]  = kwargs[:target_key]  if kwargs.key?(:target_key)
         extras["pending_key"] = kwargs[:pending_key] if kwargs.key?(:pending_key)
         @audit_log.append(
-          role: "script", verb: "event_error", key: key,
+          role: "runner", verb: "event_error", key: key,
           etag_before: nil, etag_after: nil, extras: extras
         )
       end

data/lib/textus/hooks/dsl.rb

@@ -1,17 +1,10 @@
 module Textus
   module Hooks
     module Dsl
-      EVENTS = %i[
-        intake reduce check
-        put deleted refreshed built published accepted
-        mv reject loaded
-        refresh_began refresh_failed refresh_detached
-      ].freeze
+      def on(event, name, **, &blk)
+        raise UsageError.new("hook needs a block") unless blk
 
-      EVENTS.each do |event|
-        define_method(event) do |name, **opts, &blk|
-          Loader.current_registry.register(event, name, **opts, &blk)
-        end
+        Loader.current_registry.register(event, name, **, &blk)
       end
     end
   end

data/lib/textus/hooks/loader.rb

@@ -19,8 +19,7 @@ module Textus
     end
   end
 
-  # Public DSL — unchanged surface
+  # Public DSL
   def self.with_registry(registry, &) = Hooks::Loader.with_registry(registry, &)
   def self.current_registry           = Hooks::Loader.current_registry
-  def self.hook(event, name, **, &)   = Hooks::Loader.current_registry.register(event, name, **, &)
 end

data/lib/textus/hooks/registry.rb

@@ -3,23 +3,23 @@ module Textus
     class Registry
       EVENTS = {
         # RPC: exactly 1 handler per name; return value flows into store; failure aborts.
-        intake: { mode: :rpc, args: %i[store config args] },
-        reduce: { mode: :rpc, args: %i[store rows config] },
-        check: { mode: :rpc, args: %i[store] },
+        resolve_intake: { mode: :rpc, args: %i[store config args] },
+        transform_rows: { mode: :rpc, args: %i[store rows config] },
+        validate: { mode: :rpc, args: %i[store] },
 
         # Pub-sub: 0..N handlers per event; return discarded; failure logged to audit.
-        put: { mode: :pubsub, args: %i[store key envelope] },
-        deleted: { mode: :pubsub, args: %i[store key] },
-        refreshed: { mode: :pubsub, args: %i[store key envelope change] },
-        built: { mode: :pubsub, args: %i[store key envelope sources] },
-        accepted: { mode: :pubsub, args: %i[store key target_key] },
-        published: { mode: :pubsub, args: %i[store key envelope source target] },
-        mv: { mode: :pubsub, args: %i[store key from_key to_key envelope] },
-        reject: { mode: :pubsub, args: %i[store key target_key] },
-        loaded: { mode: :pubsub, args: %i[store] },
-        refresh_began: { mode: :pubsub, args: %i[store key mode] },
+        entry_put: { mode: :pubsub, args: %i[store key envelope] },
+        entry_deleted: { mode: :pubsub, args: %i[store key] },
+        entry_refreshed: { mode: :pubsub, args: %i[store key envelope change] },
+        entry_renamed: { mode: :pubsub, args: %i[store key from_key to_key envelope] },
+        build_completed: { mode: :pubsub, args: %i[store key envelope sources] },
+        proposal_accepted: { mode: :pubsub, args: %i[store key target_key] },
+        proposal_rejected: { mode: :pubsub, args: %i[store key target_key] },
+        file_published: { mode: :pubsub, args: %i[store key envelope source target] },
+        store_loaded: { mode: :pubsub, args: %i[store] },
+        refresh_started: { mode: :pubsub, args: %i[store key mode] },
         refresh_failed: { mode: :pubsub, args: %i[store key error_class error_message] },
-        refresh_detached: { mode: :pubsub, args: %i[store key started_at budget_ms] },
+        refresh_backgrounded: { mode: :pubsub, args: %i[store key started_at budget_ms] },
       }.freeze
 
       def initialize(dispatcher: nil)
@@ -29,20 +29,21 @@ module Textus
       end
 
       def register(event, name, keys: nil, &blk)
-        spec = EVENTS[event.to_sym] or raise UsageError.new("unknown event: #{event}")
-        shape_check!(event, spec, blk)
+        event_sym = event.to_sym
+        spec = EVENTS[event_sym] or raise UsageError.new("unknown event: #{event}")
+        shape_check!(event_sym, spec, blk)
         name = name.to_sym
 
         case spec[:mode]
         when :rpc
-          raise UsageError.new("#{event} '#{name}' already registered") if @rpc[event.to_sym].key?(name)
+          raise UsageError.new("#{event_sym} '#{name}' already registered") if @rpc[event_sym].key?(name)
 
-          @rpc[event.to_sym][name] = blk
+          @rpc[event_sym][name] = blk
         when :pubsub
-          raise UsageError.new("#{event} hook '#{name}' already registered") if @pubsub[event.to_sym].any? { |h| h[:name] == name }
+          raise UsageError.new("#{event_sym} hook '#{name}' already registered") if @pubsub[event_sym].any? { |h| h[:name] == name }
 
-          @pubsub[event.to_sym] << { name: name, callable: blk, keys: keys }
-          @dispatcher&.subscribe(event, name, keys: keys, &blk)
+          @pubsub[event_sym] << { name: name, callable: blk, keys: keys }
+          @dispatcher&.subscribe(event_sym, name, keys: keys, &blk)
         end
       end
 

data/lib/textus/infra/refresh/detached.rb

@@ -21,7 +21,7 @@ module Textus
 
             begin
               store = Textus::Store.new(store_root)
-              Textus::Refresh.call(store, key, as: "script")
+              Textus::Refresh.call(store, key, as: "runner")
             rescue StandardError
               # Already logged via :refresh_failed; exit cleanly.
             ensure

data/lib/textus/init.rb

@@ -2,16 +2,16 @@ require "fileutils"
 
 module Textus
   module Init
-    ZONES = %w[identity working inbox review output].freeze
+    ZONES = %w[identity working intake review output].freeze
 
     DEFAULT_MANIFEST = <<~YAML
-      version: textus/2
+      version: textus/3
       zones:
-        - { name: identity, writable_by: [human] }
-        - { name: working,  writable_by: [human, ai, script] }
-        - { name: inbox,    writable_by: [script] }
-        - { name: review,   writable_by: [ai, human] }
-        - { name: output,   writable_by: [build] }
+        - { name: identity, write_policy: [human],               read_policy: [all] }
+        - { name: working,  write_policy: [human, agent, runner], read_policy: [all] }
+        - { name: intake,   write_policy: [runner],              read_policy: [all] }
+        - { name: review,   write_policy: [agent, human],        read_policy: [all] }
+        - { name: output,   write_policy: [builder],             read_policy: [all] }
       entries:
         - { key: identity.self, path: identity/self.md, zone: identity, schema: null, owner: human:self }
         - { key: working.notes, path: working/notes,    zone: working,  schema: null, owner: human:self, nested: true }
@@ -25,56 +25,47 @@ module Textus
       startup in alphabetical order by full path. Subdirectory names are organizational
       only — the registered event and name come from the DSL call, not the file path.
 
-      ## Per-event sugar (preferred)
+      ## DSL
 
       ```ruby
-      Textus.intake(:my_source) do |config:, args:, **|
+      Textus.on(:resolve_intake, :my_source) do |config:, args:, **|
         { _meta: { "last_refreshed_at" => Time.now.utc.iso8601 }, body: "…" }
       end
 
-      Textus.reduce(:my_source) { |rows:, **| rows.map { |r| r.merge(processed: true) } }
-      Textus.check(:my_check)   { |store:, **| { ok: true } }
-      Textus.put(:my_listener, keys: ["working.*"]) { |key:, envelope:, **| }
+      Textus.on(:transform_rows, :my_source) { |rows:, **| rows.map { |r| r.merge(processed: true) } }
+      Textus.on(:validate,       :my_check)  { |store:, **| [] }
+      Textus.on(:entry_put,      :my_listener, keys: ["working.*"]) { |key:, envelope:, **| }
 
       # Run a side-effect every time textus writes a file to your repo:
-      Textus.published(:notify) do |key:, target:, **|
+      Textus.on(:file_published, :notify) do |key:, target:, **|
         warn "wrote \#{target} (from \#{key})"
       end
       ```
 
       The intake handler above is paired with a manifest entry plus a
-      top-level `policies:` block for freshness (ttl/on_stale live in
-      policies, not in the entry):
+      top-level `rules:` block for freshness (ttl/on_stale live in
+      rules, not in the entry):
 
       ```yaml
       entries:
-        - key: inbox.foo
-          path: inbox/foo.md
-          zone: inbox
+        - key: intake.foo
+          path: intake/foo.md
+          zone: intake
           intake:
             handler: my_source
 
-      policies:
-        - match: inbox.foo
+      rules:
+        - match: intake.foo
           refresh:
             ttl: 10m
             on_stale: timed_sync   # warn | sync | timed_sync (default: warn)
       ```
 
-      ## Low-level primitive (always available)
-
-      ```ruby
-      Textus.hook(:intake, :name) { |store:, config:, args:|  ... }   # bring bytes in
-      Textus.hook(:reduce, :name) { |store:, rows:, config:|  ... }   # transform rows
-      Textus.hook(:check,  :name) { |store:|                  ... }   # doctor check
-      Textus.hook(:put,    :name, keys: ["..."])                      # lifecycle listener
-                                  { |store:, key:, envelope:| ... }
-      ```
-
-      Events: :intake, :reduce, :check (rpc — return value used)
-              :put, :deleted, :refreshed, :built, :accepted, :published,
-              :mv, :reject, :loaded,
-              :refresh_began, :refresh_failed, :refresh_detached (pub-sub — return discarded)
+      Events: :resolve_intake, :transform_rows, :validate (rpc — return value used)
+              :entry_put, :entry_deleted, :entry_refreshed, :entry_renamed,
+              :build_completed, :proposal_accepted, :proposal_rejected,
+              :file_published, :store_loaded,
+              :refresh_started, :refresh_failed, :refresh_backgrounded (pub-sub — return discarded)
 
       See SPEC.md §5.10 for the full table.
     MD

data/lib/textus/intro.rb

@@ -13,17 +13,72 @@ module Textus
     ZONE_PURPOSES = {
       "identity" => "slow-changing identity; human-only writes",
       "working" => "active project state; humans, AI, and scripts share this surface",
-      "inbox" => "declared external inputs; script-refreshed via actions",
+      "intake" => "declared external inputs; script-refreshed via actions",
       "review" => "AI proposals awaiting human accept",
       "output" => "build-computed outputs; never hand-edited",
     }.freeze
 
     WRITE_FLOWS = {
       "human" => "edit files in identity/working zones, then 'textus put KEY --as=human'",
-      "ai" => "propose changes by writing 'review.*' entries with --as=ai and a 'proposal:' frontmatter block; " \
-              "a human runs 'textus accept' to apply",
-      "script" => "refresh inbox entries with 'textus refresh KEY --as=script' (uses the entry's declared action)",
-      "build" => "'textus build' computes output entries from projections; output files are never hand-edited",
+      "agent" => "propose changes by writing 'review.*' entries with --as=agent and a 'proposal:' frontmatter block; " \
+                 "a human runs 'textus accept' to apply",
+      "runner" => "refresh intake entries with 'textus refresh KEY --as=runner' (uses the entry's declared action)",
+      "builder" => "'textus build' computes output entries from projections; output files are never hand-edited",
+    }.freeze
+
+    # Static, store-independent guide to the agent-facing protocol. Surfaced
+    # under the new top-level `agent_protocol` key in Intro.run. Recipes
+    # describe CLI verbs (not Ruby Operations) because the audience is an
+    # agent driving textus from the command line.
+    AGENT_PROTOCOL = {
+      "envelope_shape" => {
+        "summary" => "every read/write payload is a JSON envelope with _meta, body, uid, and etag",
+        "fields" => {
+          "_meta" => "hash of structured frontmatter; schema-validated per entry family",
+          "body" => "string payload (markdown/text) or nil for json/yaml formats where body lives in _meta",
+          "uid" => "stable 16-char hex identifier; preserved across writes and key renames",
+          "etag" => "content hash; pass back on writes to detect concurrent edits",
+        },
+        "ref" => "SPEC.md §8",
+      },
+      "role_resolution" => {
+        "summary" => "write role is resolved in order: --as flag, TEXTUS_ROLE env var, .textus/role file, default human",
+        "roles" => %w[human agent runner builder],
+        "ref" => "SPEC.md §5",
+      },
+      "recipes" => {
+        "read" => {
+          "purpose" => "find and read an entry",
+          "steps" => [
+            "textus list --zone=ZONE --prefix=PREFIX  # discover keys",
+            "textus get KEY                            # returns envelope JSON",
+          ],
+        },
+        "write" => {
+          "purpose" => "create or update an entry",
+          "steps" => [
+            "textus schema get FAMILY                  # learn the _meta field shape",
+            "build an envelope JSON: {_meta: {...}, body: \"...\"}",
+            "echo ENVELOPE | textus put KEY --as=ROLE --stdin",
+          ],
+        },
+        "propose" => {
+          "purpose" => "agent suggests a change for human review",
+          "agent_steps" => [
+            "echo ENVELOPE | textus put review.KEY --as=agent --stdin",
+          ],
+          "human_steps" => [
+            "textus accept review.KEY --as=human       # promotes the proposal to its target zone",
+          ],
+        },
+        "refresh" => {
+          "purpose" => "rebuild stale intake-zone caches from their declared actions",
+          "steps" => [
+            "textus freshness --zone=intake            # report fresh/stale per entry",
+            "textus refresh stale --zone=intake --as=runner",
+          ],
+        },
+      },
     }.freeze
 
     # The CLI verb catalog. Truth lives here; do not derive dynamically.
@@ -37,14 +92,14 @@ module Textus
       { "name" => "schema",   "summary" => "field shape for a key family" },
       { "name" => "put",      "summary" => "write an entry; --as=<role>, --stdin payload" },
       { "name" => "accept",   "summary" => "apply a review.* proposal; --as=human only" },
-      { "name" => "key",      "summary" => "key operations: 'key mv', 'key uid', 'key migrate'" },
+      { "name" => "key",      "summary" => "key operations: 'key mv', 'key uid', 'key normalize'" },
       { "name" => "delete",   "summary" => "delete an entry; --as=<role>" },
       { "name" => "build",    "summary" => "materialize output entries; publish_to and publish_each fan out copies" },
-      { "name" => "refresh",  "summary" => "run an action for an inbox entry" },
+      { "name" => "refresh",  "summary" => "run an action for an intake entry" },
       { "name" => "freshness", "summary" => "per-entry freshness report (status, age, ttl, on_stale)" },
       { "name" => "audit", "summary" => "query .textus/audit.log with filters (key, role, since, correlation-id, ...)" },
       { "name" => "blame", "summary" => "audit rows for one key joined with git commit metadata" },
-      { "name" => "policy", "summary" => "inspect effective policies: 'policy list', 'policy explain KEY'" },
+      { "name" => "rule", "summary" => "inspect effective rules: 'rule list', 'rule explain KEY'" },
       { "name" => "doctor", "summary" => "health-check the store (missing schemas, illegal keys, sentinel drift, etc.)" },
       { "name" => "hook",
         "summary" => "list and run registered hooks: 'hook list', 'hook run NAME'" },
@@ -59,6 +114,7 @@ module Textus
         "hooks" => hooks_for(store),
         "write_flows" => WRITE_FLOWS.dup,
         "cli_verbs" => CLI_VERBS.map(&:dup),
+        "agent_protocol" => AGENT_PROTOCOL,
         "docs" => { "spec" => "SPEC.md", "example" => "examples/claude-plugin/" },
       }
     end
@@ -74,7 +130,7 @@ module Textus
 
     def self.entries_for(store)
       store.manifest.entries.map do |e|
-        derived = store.manifest.zone_writers(e.zone).include?("build")
+        derived = store.manifest.zone_writers(e.zone).include?("builder")
         {
           "key" => e.key,
           "zone" => e.zone,