pikuri-tasks 0.0.7 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 113302bc63d0e9bd10c56550592d8e0aee68212fd1ee2cfe4032b8d1f2836b2c
-  data.tar.gz: 7d9e4351247953a5b7d7f5e54acbd68ace82404966bdeca47389b81804f2714e
+  metadata.gz: bef39f17faad60151665971aac68c2090ca08d02e343ce209ca00cdc81e4e7c5
+  data.tar.gz: bc0e54db37e868a58015c8ff18f0a9aba2a7e1232310faa608fcd4e525e2aea8
 SHA512:
-  metadata.gz: b287b65b9b99bd77966901c622aa503942cd02b09bbc8b10a2a43451dac01754136666bb7df53473990d31eed5ff2a5bd41213bdff08635bfe9657d92bce1412
-  data.tar.gz: 760eed62da11196fd09c3bcbb5bd8036e3697683bedd6d7c3eeb86ed5ce1aa2baeaf325b1780bb9ab285ef38ee12d8ec3b65773b794945cbf6ff76898b17b64f
+  metadata.gz: 6583cca82b6b2b8ac13169ce045420cb960a06157a2cc2f4da7f6ebbbbb232066ae58d9b484c4736bc509b4c78625265a5b84838cd44e9cbe2dbd94c5575fbb0
+  data.tar.gz: b778189760eb74d9ee7d882da3b308ed4bd8a020d21c2f480e6f2cc76b1868b64ea907e24f5ce132b688b14c09fcd38e8237e8825bf0a02398c31d99e077ad0e

data/lib/pikuri/tasks/completed.rb

@@ -3,14 +3,12 @@
 module Pikuri
   module Tasks
     # The +task_completed+ tool: mark the item with the given +id+ as
-    # +completed+. Same shape and rationale as {InProgress} — the
-    # status is baked into the tool name to remove the enum-typo
-    # failure mode (+"completed"+ / +"complete"+ / +"done"+), and the
-    # item is addressed by the numeric +#id+ from the rendered list.
+    # +completed+. Same shape as {InProgress} (status in the tool name,
+    # item addressed by numeric +#id+). Returns {List#render}; a bad id
+    # returns +"Error: no such task id"+ plus the current list.
     #
-    # Returns the rendered current list via {List#render} on success.
-    # On a bad id returns +"Error: no such task id: <id>"+ plus the
-    # current list, so the LLM can pick the right id in one turn.
+    # Sharing: +P_one_agent+ — closes over one agent's {List}; see its
+    # +== Sharing+.
     class Completed < Pikuri::Tool
       # @return [String]
       DESCRIPTION = <<~DESC
@@ -37,7 +35,9 @@ module Pikuri
           },
           execute: lambda { |id:|
             Completed.execute(list: list, id: id)
-          }
+          },
+          # No legs; see {Create}.
+          trifecta_legs: Pikuri::Tool::TrifectaLegs::NONE
         )
       end
 

data/lib/pikuri/tasks/create.rb

@@ -2,28 +2,22 @@
 
 module Pikuri
   module Tasks
-    # The +task_create+ tool: mass-create pending items in a single
-    # call from a JSON array of strings — a native +items+ array
-    # parameter, the shape every mainstream harness's task tool uses
-    # and therefore the shape the model's training prior produces
-    # unprompted. (An earlier newline-separated-string design tried to
-    # spare small models the bracket-balancing; in practice models
-    # sent JSON arrays anyway — the prior beats the parameter
-    # description — and the splitter turned `[`, `"foo",`, `]` into
-    # garbage tasks. Match the prior instead of fighting it.)
+    # The +task_create+ tool: mass-create pending items from a JSON array
+    # of strings — a native +items+ array parameter, the shape the model's
+    # training prior produces unprompted. (Regression guard: don't revert
+    # to a newline-separated string. An earlier such design meant to spare
+    # small models the bracket-balancing, but models sent JSON arrays
+    # anyway and the splitter turned `[`, `"foo",`, `]` into garbage tasks
+    # — match the prior, don't fight it.)
     #
-    # Each element is whitespace-stripped; a blank element aborts the
-    # call (it is always an LLM mistake, never intent). If any input
-    # is a duplicate (within the batch, or already in the list), the
-    # whole call likewise aborts with an +"Error: ..."+ string and
-    # nothing is added — the LLM resends a corrected batch on the
-    # next turn. Atomic semantics keep the list in a coherent state
-    # the LLM doesn't have to reconcile.
+    # Atomic: each element is stripped, and a blank or duplicate element
+    # (within the batch or already in the list) aborts the *whole* call
+    # with an +"Error: ..."+ string and adds nothing — the LLM resends a
+    # corrected batch, and never has to reconcile a half-applied list. On
+    # success returns {List#render}.
     #
-    # On success returns the rendered current list via {List#render} —
-    # including each new item's +#id+, which the three mutation tools
-    # address items by — so the LLM always sees fresh state without a
-    # separate read tool.
+    # Sharing: +P_one_agent+ — closes over one agent's {List}; see its
+    # +== Sharing+.
     class Create < Pikuri::Tool
       # @return [String] static description shown to the LLM,
       #   opencode-shape (summary + +Usage:+ bullets).
@@ -32,14 +26,12 @@ module Pikuri
 
         Usage:
         - Use at the start of a multi-step task to capture the plan.
-        - `items` is a JSON array of strings — one task per element.
         - A blank element, a duplicate (within the batch or already on the list), or an empty array aborts the whole call with `Error: ...` and adds nothing — resend a corrected batch.
         - On success the full current list is returned, with each task's `#id` — use that id with `task_in_progress` / `task_completed` / `task_delete`.
       DESC
 
-      # @param list [List] the shared per-Agent list, captured by
-      #   closure so every tool in the {Extension}'s set mutates the
-      #   same instance.
+      # @param list [List] the shared per-Agent list, captured by closure
+      #   so every task tool mutates the same instance.
       # @return [Create]
       def initialize(list:)
         super(
@@ -52,12 +44,13 @@ module Pikuri
           },
           execute: lambda { |items:|
             Create.execute(list: list, items: items)
-          }
+          },
+          # No legs: an in-memory, per-agent list. Nothing read from disk, nothing sent.
+          trifecta_legs: Pikuri::Tool::TrifectaLegs::NONE
         )
       end
 
-      # Validate and apply the batch. Public so specs can drive it
-      # without constructing a tool instance.
+      # Validate and apply the batch.
       #
       # @param list [List]
       # @param items [Array<String>] raw +items+ argument from the LLM

data/lib/pikuri/tasks/delete.rb

@@ -2,22 +2,15 @@
 
 module Pikuri
   module Tasks
-    # The +task_delete+ tool: remove the item with the given +id+ from
-    # the list. Used to drop items that turned out to be unnecessary,
-    # were created in error, or have been superseded — rather than
-    # leaving them sitting in +pending+ as visual noise.
+    # The +task_delete+ tool: remove the item with the given +id+.
+    # Distinct from {Completed} in intent — +completed+ means the work was
+    # done, +delete+ means the task shouldn't have been there — a
+    # distinction the tool names carry, not the list. A deleted id is never
+    # reused ({List#add}). Returns {List#render}; a bad id returns
+    # +"Error: no such task id"+ plus the current list.
     #
-    # Distinct from {Completed}: +completed+ means the work was
-    # actually done; +delete+ means the task should never have been
-    # there. The list itself draws no such distinction once an item
-    # is gone, but the LLM picks the right verb because the tool
-    # names make the intent clear. A deleted item's id is never
-    # reused (see {List#add}), so a stale id errors loudly instead of
-    # silently hitting a newer task.
-    #
-    # Returns the rendered current list via {List#render} on success.
-    # On a bad id returns +"Error: no such task id: <id>"+ plus the
-    # current list, so the LLM can pick the right id in one turn.
+    # Sharing: +P_one_agent+ — closes over one agent's {List}; see its
+    # +== Sharing+.
     class Delete < Pikuri::Tool
       # @return [String]
       DESCRIPTION = <<~DESC
@@ -43,7 +36,9 @@ module Pikuri
           },
           execute: lambda { |id:|
             Delete.execute(list: list, id: id)
-          }
+          },
+          # No legs; see {Create}.
+          trifecta_legs: Pikuri::Tool::TrifectaLegs::NONE
         )
       end
 

data/lib/pikuri/tasks/extension.rb

@@ -7,46 +7,24 @@ module Pikuri
   # event, and the {Extension} that wires them into an
   # {Pikuri::Agent}.
   module Tasks
-    # An {Pikuri::Agent::Extension} that auto-wires an in-memory
-    # task list onto an agent: constructs a fresh {List}, registers
-    # the four task tool classes against it, appends a brief
-    # workflow snippet to the system prompt, and (in {#bind}) arms
-    # {ListChanged} emission so listeners can observe every list
-    # mutation.
-    #
-    # == Usage
+    # An {Pikuri::Agent::Extension} that auto-wires an in-memory task list
+    # onto an agent: constructs a fresh {List}, registers the four task
+    # tools against it, contributes a workflow snippet, and (in {#bind})
+    # arms {ListChanged} emission.
     #
     #   Pikuri::Agent.new(transport: ..., system_prompt: ...) do |c|
     #     c.add_extension Pikuri::Tasks::Extension.new
     #   end
     #
-    # The list is per-Agent and in-memory. It is dropped when the
-    # agent is garbage-collected — nothing is written to disk.
-    #
-    # == Sub-agents
-    #
-    # Sub-agents do not inherit extensions (see CLAUDE.md's "Seams").
-    # Concretely: a sub-agent spawned by the +agent+ tool gets a
-    # fresh persona, fresh toolset, no task list. That keeps the
-    # parent's plan private to the parent and avoids the
-    # who-owns-which-task confusion a shared list would produce.
-    # If a host wants the sub-agent to also have a task list, it
-    # adds the extension to the sub-agent's own configurator —
-    # cleanly opt-in, no implicit sharing.
-    #
-    # == Empty default
-    #
-    # No +catalog+-style empty state: registering the extension
-    # always installs the four tools and the snippet. A host that
-    # doesn't want tasks simply omits the extension.
+    # Sub-agents don't inherit extensions, so a spawned sub-agent gets no
+    # task list — keeping the parent's plan private and avoiding
+    # who-owns-which-task confusion. A host wanting one adds the extension
+    # to the sub-agent's own configurator.
     class Extension
       include Pikuri::Agent::Extension
 
-      # System-prompt snippet appended once per agent. Short by
-      # design: rules-of-thumb only, no inventory (the tool
-      # descriptions cover their own usage). Mirrors the shape of
-      # opencode's +todowrite.txt+ but condensed to fit pikuri's
-      # "short prose over abstract framing" docs convention.
+      # System-prompt snippet appended once per agent. Rules-of-thumb
+      # only, no inventory (the tool descriptions cover their own usage).
       #
       # @return [String]
       PROMPT_SNIPPET = <<~PROMPT
@@ -65,8 +43,7 @@ module Pikuri
         </tasks_usage>
       PROMPT
 
-      # Tool classes the extension auto-registers. Used both for
-      # construction and for the duplicate-registration guard below.
+      # Tool classes the extension auto-registers.
       TOOL_CLASSES = [Create, InProgress, Completed, Delete].freeze
 
       # @return [Extension]
@@ -74,19 +51,16 @@ module Pikuri
         @list = List.new
       end
 
-      # @return [List] the per-agent list, exposed for tests. UI
-      #   hosts should NOT read it from another thread — the list is
-      #   agent-thread-confined; consume the {ListChanged} events
-      #   wired by {#bind} instead (each carries an immutable
-      #   snapshot safe to render from anywhere).
+      # @return [List] the per-agent list, exposed for tests. Do NOT read
+      #   it from another thread — it's agent-thread-confined; consume the
+      #   {ListChanged} events wired by {#bind} instead.
       attr_reader :list
 
-      # Construct the four tools (each sharing +@list+) and register
-      # them, then append {PROMPT_SNIPPET}. Raises if any of the four
-      # tool classes have been pre-registered via +c.add_tool+ — the
-      # whole point of the extension is to be the single owner of the
-      # shared list, and a manually pre-registered tool would bind to
-      # a different list.
+      # Construct the four tools (each sharing +@list+), register them,
+      # and append {PROMPT_SNIPPET}. Raises if any of the four were
+      # pre-registered via +c.add_tool+ — the extension is the single
+      # owner of the shared list, and a pre-registered tool would bind to
+      # a different one.
       #
       # @param c [Pikuri::Agent::Configurator]
       # @return [void]
@@ -100,16 +74,15 @@ module Pikuri
         end
 
         TOOL_CLASSES.each { |cls| c.add_tool(cls.new(list: @list)) }
-        c.append_system_prompt(PROMPT_SNIPPET)
         nil
       end
 
-      # Arm {List#on_change} to emit a {ListChanged} (carrying a
-      # fresh {List#items} snapshot) onto the agent's listener
-      # stream after every mutation. This is what lets a UI listener
-      # observe the task list without ever touching the
-      # agent-thread-confined {List} — see the Concurrency note on
-      # {List}.
+      # @return [Array<String>] the static task-workflow snippet.
+      def system_prompt_snippets = [PROMPT_SNIPPET]
+
+      # Arm {List#on_change} to emit a {ListChanged} (carrying a fresh
+      # {List#items} snapshot) after every mutation — how a UI listener
+      # observes the list without touching the agent-thread-confined {List}.
       #
       # @param ctx [Pikuri::Agent::ExtensionContext]
       # @return [void]
@@ -117,6 +90,19 @@ module Pikuri
         @list.on_change = -> { ctx.emit_event(ListChanged.new(items: @list.items)) }
         nil
       end
+
+      # Clear the task list on conversation reset — a plan is meaningless
+      # without the conversation that produced it. {List#clear} fires the
+      # armed +on_change+, so an empty {ListChanged} reaches the listener
+      # stream like any other mutation.
+      #
+      # @param ctx [Pikuri::Agent::ExtensionContext] unused; part of the
+      #   protocol signature.
+      # @return [void]
+      def on_conversation_reset(_ctx)
+        @list.clear
+        nil
+      end
     end
   end
 end

data/lib/pikuri/tasks/in_progress.rb

@@ -2,21 +2,19 @@
 
 module Pikuri
   module Tasks
-    # The +task_in_progress+ tool: mark the item with the given +id+
-    # as +in_progress+. The status name is baked into the tool name
-    # rather than passed as a parameter — that takes one degree of
-    # freedom away from the LLM (no +"in-progress"+ vs +"in_progress"+
-    # vs +"inprogress"+ typos) at the cost of one extra tool class.
+    # The +task_in_progress+ tool: mark the item with the given +id+ as
+    # +in_progress+. The status is baked into the tool name, not a
+    # parameter — one fewer degree of freedom for the LLM (no
+    # +"in-progress"+/+"inprogress"+ typos) at the cost of one tool class.
     #
-    # Items are addressed by the numeric +#id+ shown in every rendered
-    # list (an earlier design used the content string as identifier;
-    # one near-miss in reproducing the exact bytes — a stray quote, a
-    # trailing comma — and the LLM is locked out of its own list. An
-    # id is two digits it just read back; nothing to mis-transcribe.)
+    # Items are addressed by numeric +#id+, not content string (regression
+    # guard: an earlier content-as-id design locked the LLM out of its own
+    # list on one near-miss byte — a stray quote or trailing comma; an id
+    # is two digits it just read back). Returns {List#render}; a bad id
+    # returns +"Error: no such task id"+ plus the current list.
     #
-    # Returns the rendered current list via {List#render} on success.
-    # On a bad id returns +"Error: no such task id: <id>"+ plus the
-    # current list, so the LLM can pick the right id in one turn.
+    # Sharing: +P_one_agent+ — closes over one agent's {List}; see its
+    # +== Sharing+.
     class InProgress < Pikuri::Tool
       # @return [String]
       DESCRIPTION = <<~DESC
@@ -42,7 +40,9 @@ module Pikuri
           },
           execute: lambda { |id:|
             InProgress.execute(list: list, id: id)
-          }
+          },
+          # No legs; see {Create}.
+          trifecta_legs: Pikuri::Tool::TrifectaLegs::NONE
         )
       end
 

data/lib/pikuri/tasks/list.rb

@@ -2,55 +2,44 @@
 
 module Pikuri
   module Tasks
-    # Raised by {List#add} when a new item's +content+ already appears
-    # in the list. Items are addressed by {Item#id}, so duplicates
-    # would not be ambiguous — they are rejected because a duplicate
-    # is almost always an LLM mistake (re-sending an already-captured
-    # plan), and catching it early keeps the list coherent. The
-    # exception carries the offending content string so the tool layer
-    # can surface it verbatim in the +"Error: ..."+ observation.
+    # Raised by {List#add} when a new item's +content+ already appears in
+    # the list — rejected because a duplicate is almost always an LLM
+    # mistake (re-sending an already-captured plan). Carries the offending
+    # content for the +"Error: ..."+ observation.
     class DuplicateItem < StandardError; end
 
-    # Raised by {List#set_status} and {List#delete} when no item with
-    # the given +id+ exists. The three mutation tools rescue this and
-    # report +"Error: no such task id: <id>"+ plus the current list
-    # render, so the LLM can pick the right id on the next turn.
+    # Raised by {List#set_status} and {List#delete} when no item with the
+    # given +id+ exists; the mutation tools rescue it into an +"Error: no
+    # such task id"+ observation.
     class ItemNotFound < StandardError; end
 
-    # Allowed values for {Item#status}. Kept deliberately small — three
-    # states match the workflow the prompt advertises (pending → in_progress
-    # → completed) without inviting a +cancelled+ vs +deleted+ debate.
-    # +task_delete+ removes items outright rather than introducing a
-    # fourth status.
+    # Allowed values for {Item#status}. Deliberately three — the workflow
+    # the prompt advertises (pending → in_progress → completed) — with
+    # +task_delete+ removing items outright rather than adding a fourth
+    # +cancelled+/+deleted+ status.
     STATUSES = %w[pending in_progress completed].freeze
 
     # One row in a {List}. +id+ is the numeric identifier the mutation
-    # tools address the item by (assigned by {List#add}, never reused —
-    # see there); +content+ is the LLM-visible task text; +status+ is
-    # one of {STATUSES}.
+    # tools address the item by (assigned by {List#add}, never reused);
+    # +content+ is the LLM-visible task text; +status+ is one of {STATUSES}.
     Item = Data.define(:id, :content, :status)
 
     # An in-memory ordered list of {Item}s, scoped to a single
-    # {Pikuri::Agent}. Held inside {Extension} and captured by closure
-    # into the +execute+ block of each of the four task tool classes,
-    # so every mutation hits the same instance.
+    # {Pikuri::Agent}, shared by closure into all four task tools so every
+    # mutation hits the same instance.
     #
-    # == Concurrency
+    # Not persisted: dropped when the +Agent+ is collected, matching the
+    # gem's "in-memory only" scope.
     #
-    # The list is confined to the agent's thread: the agent loop is
-    # single-threaded with respect to tool calls (ruby_llm dispatches
-    # them sequentially), so no locking. Other threads (e.g. a web UI
-    # rendering the list) must not touch a +List+ directly — they
-    # consume the {ListChanged} events {Extension#bind} wires onto
-    # the listener stream, whose +items+ payload is an immutable
-    # snapshot safe to hand across threads. A future
-    # parallel-tool-execution feature would need a +Mutex+ here.
+    # == Sharing
     #
-    # == Persistence
-    #
-    # None. The list is dropped when the +Agent+ is garbage-collected.
-    # That matches the gem's stated scope: "in-memory only, no
-    # session-state-on-disk."
+    # +P_one_agent+ — this is one conversation's plan, so two agents on one
+    # list would read and complete each other's tasks. Unguarded, and it needs
+    # no lock because its only caller is the agent whose tool calls are already
+    # serialized. Another thread (a UI rendering the list) must not touch a
+    # +List+ directly: it consumes the {ListChanged} events {Extension#bind}
+    # wires onto the listener stream, whose +items+ payload is an immutable
+    # snapshot safe to hand across threads.
     class List
       # @return [List]
       def initialize
@@ -59,13 +48,10 @@ module Pikuri
         @on_change = nil
       end
 
-      # Optional zero-argument hook invoked after every successful
-      # mutation ({#add} / {#set_status} / {#delete}) — not on failed
-      # ones (a raise means nothing changed). Set by {Extension#bind}
-      # to emit a {ListChanged} onto the agent's listener stream;
-      # +nil+ (the default) disables notification. Runs on the
-      # mutating (agent) thread, synchronously inside the mutation
-      # call.
+      # Optional zero-argument hook invoked synchronously after every
+      # *successful* mutation (a raise means nothing changed, so no
+      # notify). Set by {Extension#bind} to emit a {ListChanged}; +nil+
+      # (default) disables notification.
       #
       # @return [Proc, nil]
       attr_accessor :on_change
@@ -95,8 +81,7 @@ module Pikuri
       # @param content [String] non-empty content; whitespace is the
       #   caller's responsibility.
       # @return [Item] the newly added item
-      # @raise [DuplicateItem] if an item with the same +content+
-      #   already exists (a duplicate is almost always an LLM mistake).
+      # @raise [DuplicateItem] if an item with the same +content+ exists.
       def add(content)
         raise DuplicateItem, content if @items.any? { |i| i.content == content }
 
@@ -143,10 +128,23 @@ module Pikuri
         removed
       end
 
-      # The canonical rendering returned as the observation by every
-      # task tool, so the LLM sees the latest full state — including
-      # each item's id — on each call without needing a separate read
-      # tool. Format:
+      # Drop every item and rewind the id counter to 1, then fire
+      # {#on_change} (always, even when already empty, so a UI listener
+      # sees the cleared state). Rewinding +@next_id+ is safe here — unlike
+      # after {#delete}, a clear wipes the model's context too, so no stale
+      # id survives to collide with a reused one.
+      #
+      # @return [void]
+      def clear
+        @items = []
+        @next_id = 1
+        @on_change&.call
+        nil
+      end
+
+      # The canonical rendering every task tool returns as its
+      # observation, so the LLM sees the full state (ids included) each
+      # call without a separate read tool:
       #
       #   <tasks>
       #   - #1 [pending] Add dark mode toggle
@@ -154,9 +152,8 @@ module Pikuri
       #   - #3 [completed] Update README
       #   </tasks>
       #
-      # Empty list renders as +<tasks>(empty)</tasks>+ so the LLM gets
-      # an unambiguous "yes, the call worked and the list is now empty"
-      # signal rather than an ambiguous blank block.
+      # Empty renders as +<tasks>(empty)</tasks>+ — an unambiguous "the
+      # call worked, list is now empty" rather than a blank block.
       #
       # @return [String]
       def render

data/lib/pikuri/tasks/list_changed.rb

@@ -2,25 +2,17 @@
 
 module Pikuri
   module Tasks
-    # Domain event emitted onto the agent's listener stream after
-    # every {List} mutation (add / status change / delete), wired by
-    # {Extension#bind} via
+    # Domain event emitted after every {List} mutation (add / status
+    # change / delete), wired by {Extension#bind} via
     # {Pikuri::Agent::ExtensionContext#emit_event}. Carries a frozen
-    # point-in-time snapshot of the whole list ({List#items}'s
-    # shape), so a consumer needs no +List+ reference — render or
-    # serialize the payload as-is.
+    # whole-list snapshot ({List#items}), so a consumer needs no +List+
+    # reference — render or serialize the payload as-is.
     #
-    # Lands between the mutating tool's {Pikuri::Agent::Event::ToolCall}
-    # and {Pikuri::Agent::Event::ToolResult} in the stream (the
-    # +on_change+ hook fires inside the tool's +execute+). A batch
-    # +task_create+ emits one event per added item — consumers that
-    # render should treat the latest snapshot as authoritative
-    # (last-wins) rather than diffing event-by-event.
-    #
-    # Fired on the agent's thread. A listener feeding another thread
-    # (e.g. a web UI pushing over SSE) should serialize inside
-    # +on_event+ and hand off only the immutable result — see the
-    # Concurrency note on {List}.
+    # A batch +task_create+ emits one event per added item, so a renderer
+    # should treat the latest snapshot as authoritative (last-wins), not
+    # diff event-by-event. Fired on the agent's thread — a listener
+    # feeding another thread serializes inside +on_event+ and hands off
+    # only the immutable result (see {List}'s thread-confinement note).
     ListChanged = Data.define(:items)
   end
 end

data/lib/pikuri-tasks.rb

@@ -2,16 +2,8 @@
 
 require 'pikuri-core'
 
-# Entry file for the pikuri-tasks gem. Sets up a dedicated Zeitwerk
-# loader rooted at this gem's +lib/+, contributing to the shared
-# +Pikuri::+ namespace alongside pikuri-core. After +require
-# 'pikuri-tasks'+, +Pikuri::Tasks::List+, the four task tool classes
-# (+Create+, +InProgress+, +Completed+, +Delete+), and
-# +Pikuri::Tasks::Extension+ are all defined.
-#
-# The loader is per-gem (not shared with pikuri-core's loader) so each
-# gem owns its own +lib/+ tree and the cooperation between gems is via
-# the Pikuri namespace alone.
+# Entry file for the pikuri-tasks gem: sets up the per-gem Zeitwerk
+# loader. See {Pikuri::Tasks} for the namespace overview.
 module Pikuri
   module Tasks
     LOADER = Zeitwerk::Loader.new

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pikuri-tasks
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.1.0
 platform: ruby
 authors:
 - Martin Vysny
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.7
+        version: 0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.7
+        version: 0.1.0
 description: |
   pikuri-tasks gives a pikuri-core agent an in-memory task list it
   can use to plan and track multi-step work. A +Pikuri::Tasks::List+