pikuri-tasks 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 532d85628fc253786ae595ad4a26e47ecf6c7b0e116f14d41d211a32ebaeb084
+  data.tar.gz: 840465bdd7eed7f31a28b3f59ee2b1784f27cf07e2819323d66e60c1f4e4a99e
+SHA512:
+  metadata.gz: 1ea43022b727733934abb762cf62d604c3fabde847ca7e10c0fdbd2cb53000f41c4fc83b822e023e41555eb9b610cbfd5a249decf4352bda53c447f0ea5cd050
+  data.tar.gz: c6f8e656609113785b062f197e79b87b5753c5cc6290b05f5442b6b1652ede03530f9ffd39f39b14ae542b64ddaf469c82e7d5cd7383999d2a3531d346da1e32

data/README.md

@@ -0,0 +1,79 @@
+# pikuri-tasks
+
+In-memory task list + four LLM-facing tools for the
+[pikuri](https://codeberg.org/mvysny/pikuri) AI-assistant toolkit.
+
+Provides:
+- `Pikuri::Tasks::List` — per-Agent in-memory list of
+  `(content, status)` items. Status is one of `pending`,
+  `in_progress`, `completed`. Nothing is written to disk.
+- Four tool classes, all sharing one `List` instance:
+  - `Pikuri::Tasks::Create` (`task_create`) — mass-create pending
+    items from a newline-separated `items` string. Atomic: if any
+    line is a duplicate (within the batch or already on the list),
+    nothing is added.
+  - `Pikuri::Tasks::InProgress` (`task_in_progress`) — mark an item
+    as `in_progress` by content.
+  - `Pikuri::Tasks::Completed` (`task_completed`) — mark an item as
+    `completed` by content.
+  - `Pikuri::Tasks::Delete` (`task_delete`) — remove an item by
+    content.
+- `Pikuri::Tasks::Extension` — wires the four tools + a brief
+  `<tasks_usage>` workflow snippet into a `Pikuri::Agent` via the
+  `c.add_extension(...)` block API.
+
+Two shape choices worth flagging:
+- **Status is baked into the tool name** (no `status:` parameter
+  with an enum). Removes the `"in-progress"` vs `"in_progress"`
+  vs `"inprogress"` typo failure mode on smaller models.
+- **Content doubles as identifier** across the three update tools
+  (no item IDs to bookkeep). Duplicates are rejected on
+  `task_create` so the identifier stays unique.
+
+## Install
+
+```ruby
+# Gemfile
+gem 'pikuri-tasks'
+```
+
+## Usage
+
+```ruby
+require 'pikuri-core'
+require 'pikuri-tasks'
+
+agent = Pikuri::Agent.new(transport: ..., system_prompt: ...) do |c|
+  c.add_extension(Pikuri::Tasks::Extension.new)
+end
+```
+
+The extension's `configure` constructs a fresh `Tasks::List`,
+registers all four task tools against it (so they mutate the same
+instance), and appends a short `<tasks_usage>` snippet to the system
+prompt explaining the workflow (create at the start, exactly one
+`in_progress` at a time, `completed` only after verification).
+
+Every mutation returns the full rendered list as its observation,
+so the LLM always sees fresh state without a separate read tool:
+
+```
+<tasks>
+- [pending] Add dark mode toggle
+- [in_progress] Write unit tests
+- [completed] Update README
+</tasks>
+```
+
+Empty renders as `<tasks>(empty)</tasks>` so the LLM gets an
+unambiguous "the call worked and the list is now empty" signal.
+
+Sub-agents do **not** inherit extensions — a sub-agent spawned by
+the `agent` tool gets a fresh persona and no task list. The
+parent's plan stays private to the parent.
+
+## Further reading
+
+- **API reference:** browse the YARD docs at
+  <https://rubydoc.info/gems/pikuri-tasks> (once published), or
+  run `bundle exec yard` in this directory for a local copy.

data/lib/pikuri/tasks/completed.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Pikuri
+  module Tasks
+    # The +task_completed+ tool: mark the item whose +content+ exactly
+    # matches as +completed+. Same shape and rationale as
+    # {InProgress} — the status is baked into the tool name to remove
+    # the enum-typo failure mode small models hit on
+    # +"completed"+ / +"complete"+ / +"done"+.
+    #
+    # Returns the rendered current list via {List#render} on success,
+    # or +"Error: no such task: '<content>'"+ when the content does
+    # not match.
+    class Completed < Pikuri::Tool
+      # @return [String]
+      DESCRIPTION = <<~DESC
+        Mark a task as `completed` once the work — including any required verification — is actually done.
+
+        Usage:
+        - Pass the exact `content` string the task was created with.
+        - Do NOT mark `completed` based on intent; mark it only after the underlying work is verified.
+        - If the work is partially done or blocked, leave the task `in_progress` and add a follow-up via `task_create`.
+        - On `Error: no such task: ...` the call did nothing — read the returned list in any subsequent tool's output to pick the right name.
+        - On success the full current list is returned for you to read back.
+      DESC
+
+      # @param list [List]
+      # @return [Completed]
+      def initialize(list:)
+        super(
+          name: 'task_completed',
+          description: DESCRIPTION,
+          parameters: Pikuri::Tool::Parameters.build { |p|
+            p.required_string :content,
+                              'Exact content of the existing task to mark as ' \
+                              'completed, e.g. "Add dark mode toggle".'
+          },
+          execute: lambda { |content:|
+            Completed.execute(list: list, content: content)
+          }
+        )
+      end
+
+      # @param list [List]
+      # @param content [String]
+      # @return [String]
+      def self.execute(list:, content:)
+        list.set_status(content: content, status: 'completed')
+        list.render
+      rescue ItemNotFound
+        "Error: no such task: '#{content}'"
+      end
+    end
+  end
+end

data/lib/pikuri/tasks/create.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Pikuri
+  module Tasks
+    # The +task_create+ tool: mass-create pending items in a single
+    # call from a newline-separated +items+ string. Why
+    # newline-separated rather than a JSON array: it stays within
+    # pikuri's scalar-only +Tool::Parameters+ DSL (no array support
+    # to extend), and a smaller model never has to balance brackets
+    # or escape quotes — fewer formatting failure modes on the burst
+    # of items that opens most multi-step work.
+    #
+    # Each line is right- and left-stripped; blank lines are skipped.
+    # If any input is a duplicate (within the batch, or already in
+    # the list), the whole call 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.
+    #
+    # On success returns the rendered current list via {List#render},
+    # so the LLM always sees fresh state without a separate read tool.
+    class Create < Pikuri::Tool
+      # @return [String] static description shown to the LLM,
+      #   opencode-shape (summary + +Usage:+ bullets).
+      DESCRIPTION = <<~DESC
+        Create one or more new task items in a single call. All items start as `pending`.
+
+        Usage:
+        - Use at the start of a multi-step task to capture the plan.
+        - `items` is a single newline-separated string — one task per line. Blank lines are ignored.
+        - Duplicate content (within the batch or already on the list) aborts the whole call with `Error: ...` and adds nothing — resend a corrected batch.
+        - Empty input is rejected the same way.
+        - On success the full current list is returned for you to read back.
+      DESC
+
+      # @param list [List] the shared per-Agent list, captured by
+      #   closure so every tool in the {Extension}'s set mutates the
+      #   same instance.
+      # @return [Create]
+      def initialize(list:)
+        super(
+          name: 'task_create',
+          description: DESCRIPTION,
+          parameters: Pikuri::Tool::Parameters.build { |p|
+            p.required_string :items,
+                              'Newline-separated list of task contents, e.g. ' \
+                              '"Add dark mode toggle\nWrite unit tests\nUpdate README". ' \
+                              'Blank lines are ignored.'
+          },
+          execute: lambda { |items:|
+            Create.execute(list: list, items: items)
+          }
+        )
+      end
+
+      # Validate and apply the batch. Public so specs can drive it
+      # without constructing a tool instance.
+      #
+      # @param list [List]
+      # @param items [String] raw +items+ argument from the LLM.
+      # @return [String] either {List#render} on success or an
+      #   +"Error: ..."+ string the LLM can react to.
+      def self.execute(list:, items:)
+        cleaned = items.lines.map(&:strip).reject(&:empty?)
+        return 'Error: task_create requires at least one non-blank item' if cleaned.empty?
+
+        seen_in_batch = {}
+        cleaned.each do |c|
+          return "Error: duplicate item in batch: '#{c}'" if seen_in_batch[c]
+
+          seen_in_batch[c] = true
+        end
+
+        existing = list.items.map(&:content)
+        clash = cleaned.find { |c| existing.include?(c) }
+        return "Error: task already exists: '#{clash}'" if clash
+
+        cleaned.each { |c| list.add(c) }
+        list.render
+      end
+    end
+  end
+end

data/lib/pikuri/tasks/delete.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Pikuri
+  module Tasks
+    # The +task_delete+ tool: remove the item whose +content+ exactly
+    # matches 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.
+    #
+    # 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.
+    #
+    # Returns the rendered current list via {List#render} on success,
+    # or +"Error: no such task: '<content>'"+ when the content does
+    # not match.
+    class Delete < Pikuri::Tool
+      # @return [String]
+      DESCRIPTION = <<~DESC
+        Remove a task from the list. Use this for items that turn out not to be needed, were created in error, or have been superseded.
+
+        Usage:
+        - Pass the exact `content` string the task was created with.
+        - Use `task_completed` (not this) when the work was actually done.
+        - On `Error: no such task: ...` the call did nothing — read the returned list in any subsequent tool's output to pick the right name.
+        - On success the full current list is returned for you to read back.
+      DESC
+
+      # @param list [List]
+      # @return [Delete]
+      def initialize(list:)
+        super(
+          name: 'task_delete',
+          description: DESCRIPTION,
+          parameters: Pikuri::Tool::Parameters.build { |p|
+            p.required_string :content,
+                              'Exact content of the existing task to remove, ' \
+                              'e.g. "Add dark mode toggle".'
+          },
+          execute: lambda { |content:|
+            Delete.execute(list: list, content: content)
+          }
+        )
+      end
+
+      # @param list [List]
+      # @param content [String]
+      # @return [String]
+      def self.execute(list:, content:)
+        list.delete(content)
+        list.render
+      rescue ItemNotFound
+        "Error: no such task: '#{content}'"
+      end
+    end
+  end
+end

data/lib/pikuri/tasks/extension.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Pikuri
+  # Namespace for the in-memory task-list feature. Holds the
+  # {List} value type, the four task tool classes ({Create},
+  # {InProgress}, {Completed}, {Delete}), 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, and appends a brief
+    # workflow snippet to the system prompt.
+    #
+    # == Usage
+    #
+    #   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.
+    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.
+      #
+      # @return [String]
+      PROMPT_SNIPPET = <<~PROMPT
+        <tasks_usage>
+        You have an in-memory task list. Use it to plan and track multi-step work.
+
+        Workflow:
+        - When a task has 3+ steps, call `task_create` once with the full plan (newline-separated items, all start as `pending`).
+        - Before starting an item, call `task_in_progress` with its exact content. Keep exactly one item `in_progress` at a time.
+        - When an item is fully done (including any required verification), call `task_completed` with its exact content.
+        - Use `task_delete` to remove items that turn out not to be needed.
+
+        Skip task tracking entirely for single-step or purely informational requests — it adds noise, not value.
+
+        Every mutation returns the full current list, so you do not need a separate read tool. Content doubles as identifier across the four tools: spelling and capitalization must match exactly.
+        </tasks_usage>
+      PROMPT
+
+      # Tool classes the extension auto-registers. Used both for
+      # construction and for the duplicate-registration guard below.
+      TOOL_CLASSES = [Create, InProgress, Completed, Delete].freeze
+
+      # @return [Extension]
+      def initialize
+        @list = List.new
+      end
+
+      # @return [List] the per-agent list, exposed for tests and for
+      #   hosts that want to render it in a UI (a future TUI could
+      #   surface +list.items+ in a sidebar).
+      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.
+      #
+      # @param c [Pikuri::Agent::Configurator]
+      # @return [void]
+      def configure(c)
+        TOOL_CLASSES.each do |cls|
+          if c.tools.any?(cls)
+            raise "#{cls} cannot be pre-registered (in tools: or via c.add_tool) " \
+                  'when adding Pikuri::Tasks::Extension — the extension auto-registers all four task tools ' \
+                  'so they share the same in-memory list.'
+          end
+        end
+
+        TOOL_CLASSES.each { |cls| c.add_tool(cls.new(list: @list)) }
+        c.append_system_prompt(PROMPT_SNIPPET)
+        nil
+      end
+    end
+  end
+end

data/lib/pikuri/tasks/in_progress.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Pikuri
+  module Tasks
+    # The +task_in_progress+ tool: mark the item whose +content+
+    # exactly matches 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.
+    #
+    # Returns the rendered current list via {List#render} on success,
+    # or +"Error: no such task: '<content>'"+ when the content does
+    # not match — the LLM can read the returned list to find the
+    # closest match and re-call.
+    class InProgress < Pikuri::Tool
+      # @return [String]
+      DESCRIPTION = <<~DESC
+        Mark a task as `in_progress` immediately before you start working on it.
+
+        Usage:
+        - Pass the exact `content` string the task was created with — content doubles as identifier; spelling and capitalization must match.
+        - Keep exactly one task `in_progress` at a time. Finish (or revert) the current one before starting another.
+        - On `Error: no such task: ...` the call did nothing — read the returned list in any subsequent tool's output to pick the right name.
+        - On success the full current list is returned for you to read back.
+      DESC
+
+      # @param list [List]
+      # @return [InProgress]
+      def initialize(list:)
+        super(
+          name: 'task_in_progress',
+          description: DESCRIPTION,
+          parameters: Pikuri::Tool::Parameters.build { |p|
+            p.required_string :content,
+                              'Exact content of the existing task to mark as ' \
+                              'in_progress, e.g. "Add dark mode toggle".'
+          },
+          execute: lambda { |content:|
+            InProgress.execute(list: list, content: content)
+          }
+        )
+      end
+
+      # @param list [List]
+      # @param content [String]
+      # @return [String]
+      def self.execute(list:, content:)
+        list.set_status(content: content, status: 'in_progress')
+        list.render
+      rescue ItemNotFound
+        "Error: no such task: '#{content}'"
+      end
+    end
+  end
+end

data/lib/pikuri/tasks/list.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Pikuri
+  module Tasks
+    # Raised by {List#add} when a new item's +content+ already appears
+    # in the list. Content doubles as identifier in the task tools, so
+    # duplicates would make +task_in_progress+ / +task_completed+ /
+    # +task_delete+ ambiguous. The exception carries the offending
+    # content string so the tool layer can surface it verbatim in the
+    # +"Error: ..."+ observation.
+    class DuplicateItem < StandardError; end
+
+    # Raised by {List#set_status} and {List#delete} when no item with
+    # the given +content+ exists. The four task tools rescue this and
+    # report +"Error: no such task: <content>"+ so the LLM can correct
+    # the name on the next turn.
+    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.
+    STATUSES = %w[pending in_progress completed].freeze
+
+    # One row in a {List}. +content+ is the LLM-visible string that
+    # also acts as identifier across the four task tools; +status+ is
+    # one of {STATUSES}.
+    Item = Data.define(: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.
+    #
+    # == Concurrency
+    #
+    # The agent loop is single-threaded with respect to tool calls
+    # (ruby_llm dispatches them sequentially), so no locking. A future
+    # parallel-tool-execution feature would need a +Mutex+ here.
+    #
+    # == 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."
+    class List
+      # @return [List]
+      def initialize
+        @items = []
+      end
+
+      # @return [Array<Item>] a frozen snapshot of the current items,
+      #   in insertion order. Callers cannot mutate the internal
+      #   storage through this accessor.
+      def items
+        @items.dup.freeze
+      end
+
+      # @return [Integer]
+      def size
+        @items.size
+      end
+
+      # @return [Boolean]
+      def empty?
+        @items.empty?
+      end
+
+      # Append a new item with status +pending+. Content matching is
+      # exact (no case- or whitespace-folding) since the tools quote
+      # the content back to the LLM as the identifier.
+      #
+      # @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.
+      def add(content)
+        raise DuplicateItem, content if find(content)
+
+        item = Item.new(content: content, status: 'pending')
+        @items << item
+        item
+      end
+
+      # Update the status of the item whose +content+ matches.
+      #
+      # @param content [String]
+      # @param status [String] one of {STATUSES}.
+      # @return [Item] the updated item (a fresh frozen +Data+
+      #   instance — the old one is replaced in place).
+      # @raise [ItemNotFound] if no matching item exists.
+      # @raise [ArgumentError] if +status+ is not in {STATUSES}.
+      def set_status(content:, status:)
+        unless STATUSES.include?(status)
+          raise ArgumentError, "invalid status: #{status.inspect} (allowed: #{STATUSES.join(', ')})"
+        end
+
+        idx = @items.index { |i| i.content == content }
+        raise ItemNotFound, content if idx.nil?
+
+        @items[idx] = Item.new(content: content, status: status)
+        @items[idx]
+      end
+
+      # Remove the item whose +content+ matches.
+      #
+      # @param content [String]
+      # @return [Item] the removed item.
+      # @raise [ItemNotFound] if no matching item exists.
+      def delete(content)
+        idx = @items.index { |i| i.content == content }
+        raise ItemNotFound, content if idx.nil?
+
+        @items.delete_at(idx)
+      end
+
+      # The canonical rendering returned as the observation by every
+      # task tool, so the LLM sees the latest full state on each call
+      # without needing a separate read tool. Format:
+      #
+      #   <tasks>
+      #   - [pending] Add dark mode toggle
+      #   - [in_progress] Write unit tests
+      #   - [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.
+      #
+      # @return [String]
+      def render
+        return '<tasks>(empty)</tasks>' if @items.empty?
+
+        lines = @items.map { |i| "- [#{i.status}] #{i.content}" }
+        "<tasks>\n#{lines.join("\n")}\n</tasks>"
+      end
+
+      private
+
+      def find(content)
+        @items.find { |i| i.content == content }
+      end
+    end
+  end
+end

data/lib/pikuri-tasks.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+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.
+module Pikuri
+  module Tasks
+    LOADER = Zeitwerk::Loader.new
+    LOADER.tag = 'pikuri-tasks'
+    LOADER.push_dir(File.expand_path('.', __dir__))
+    LOADER.ignore(__FILE__)
+    LOADER.setup
+    LOADER.eager_load
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: pikuri-tasks
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Martin Vysny
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-05-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pikuri-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+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+
+  holds the per-Agent state; four tools (+task_create+,
+  +task_in_progress+, +task_completed+, +task_delete+) mutate it via
+  content-as-identifier (no item IDs to hallucinate).
+  +Pikuri::Tasks::Extension+ wires the list and tools onto an
+  +Pikuri::Agent+ via +c.add_extension(...)+ inside the +Agent.new+
+  block.
+
+  The list lives in process memory only — nothing is written to disk.
+  Sub-agents do not inherit the parent's list (consistent with the
+  "sub-agents do not inherit extensions" rule).
+email:
+- martin@vysny.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/pikuri-tasks.rb
+- lib/pikuri/tasks/completed.rb
+- lib/pikuri/tasks/create.rb
+- lib/pikuri/tasks/delete.rb
+- lib/pikuri/tasks/extension.rb
+- lib/pikuri/tasks/in_progress.rb
+- lib/pikuri/tasks/list.rb
+homepage: https://codeberg.org/mvysny/pikuri
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://codeberg.org/mvysny/pikuri/src/branch/master
+  changelog_uri: https://codeberg.org/mvysny/pikuri/src/branch/master/CHANGELOG.md
+  bug_tracker_uri: https://codeberg.org/mvysny/pikuri/issues
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Per-session in-memory task list + tools for pikuri.
+test_files: []