@pingvinen/donna-assistant 0.9.1 → 0.11.0

package/workflows/follow-up.md

@@ -0,0 +1,163 @@
+# Donna Follow-Up Workflow
+
+<objective>
+Capture a follow-up task with a future due date, resolve relative time expressions to concrete dates, store in donna/follow-ups.md, and commit via donna-tools.cjs.
+</objective>
+
+<step name="init">
+Run via Bash:
+```bash
+INIT=$(node ~/.donna/donna-tools.cjs init)
+```
+
+Parse the JSON response. If the `error` field is `"not_configured"`, print:
+```
+x Donna is not configured. Run /donna:setup first.
+```
+Stop.
+
+Extract `storage_repo`, `daily_folder`, `auto_push` from the JSON.
+
+If `update_available` is non-null, print:
+```
+Donna v<update_available> available -- run npx @pingvinen/donna-assistant to update
+```
+Continue normally.
+</step>
+
+<step name="parse-input">
+The argument is the full user text (e.g., "/donna:add-follow-up-task remind team about Q3 planning in 2 months").
+
+**If an argument was provided:**
+Use language understanding to extract two things from the argument:
+1. `<description>`: The task description (everything that is not a time expression)
+2. `<due_expression>`: A time expression (e.g., "in 2 months", "on 2026-09-15", "next Tuesday", "in 3 weeks") — or null if no time expression is found
+
+Examples:
+- "remind team about Q3 planning in 2 months" → description: "remind team about Q3 planning", due_expression: "in 2 months"
+- "call dentist on 2026-09-15" → description: "call dentist", due_expression: "on 2026-09-15"
+- "review the design doc" → description: "review the design doc", due_expression: null
+- "/donna:add-follow-up-task schedule 1:1 with Sarah next Tuesday at 2pm" → description: "schedule 1:1 with Sarah", due_expression: "next Tuesday"
+
+**If no argument was provided:**
+CRITICAL: Both AskUserQuestion prompts must use free-text input mode — do NOT use a picker with predefined options.
+
+Print the following as prose (before asking any questions):
+```
+Time expression examples: "in 2 months", "on 2026-09-15", "next Tuesday", "in 3 weeks", or leave blank for today.
+```
+
+Use AskUserQuestion to ask two questions:
+
+First question:
+```
+What task would you like to schedule?
+```
+Store the free-text response as `<description>`.
+
+Second question:
+```
+When is it due?
+```
+Store the free-text response as `<due_expression>`. If the user leaves it blank or says "today", set `<due_expression>` to null.
+</step>
+
+<step name="resolve-date">
+Three cases for resolving the due date:
+
+**Case 1: due_expression is null**
+Use today's date. Run via Bash:
+```bash
+node -e "const d=new Date();const y=d.getFullYear();const m=String(d.getMonth()+1).padStart(2,'0');const dd=String(d.getDate()).padStart(2,'0');console.log(y+'-'+m+'-'+dd)"
+```
+Store the output as `<due_date>`.
+
+**Case 2: due_expression matches YYYY-MM-DD format**
+Extract the YYYY-MM-DD part from the expression (strip any leading words like "on"). Store directly as `<due_date>`.
+
+**Case 3: due_expression is a relative expression**
+The agent parses the natural language expression into structured {value, unit} pairs:
+- "in 2 months" → months: 2
+- "in 3 weeks" → weeks: 3
+- "in 2 weeks and 3 days" → weeks: 2, days: 3
+- "in 1 month and 2 weeks" → months: 1, weeks: 2
+- "in 2 months and 5 days" → months: 2, days: 5
+- "next Tuesday" → next occurrence of Tuesday from today (count days until the next Tuesday)
+- "tomorrow" → days: 1
+- "in 5 days" → days: 5
+
+Inject the arithmetic into a Bash node -e command. Command template:
+```bash
+node -e "
+const d = new Date();
+<apply setMonth first: d.setMonth(d.getMonth() + N)>
+<apply setDate next: d.setDate(d.getDate() + N)>
+<apply setFullYear last: d.setFullYear(d.getFullYear() + N)>
+const yyyy = d.getFullYear();
+const mm = String(d.getMonth() + 1).padStart(2, '0');
+const dd = String(d.getDate()).padStart(2, '0');
+console.log(yyyy + '-' + mm + '-' + dd);
+"
+```
+
+Example for "in 2 months and 5 days":
+```bash
+node -e "const d=new Date();d.setMonth(d.getMonth()+2);d.setDate(d.getDate()+5);const y=d.getFullYear();const m=String(d.getMonth()+1).padStart(2,'0');const dd=String(d.getDate()).padStart(2,'0');console.log(y+'-'+m+'-'+dd)"
+```
+
+Example for "in 3 weeks":
+```bash
+node -e "const d=new Date();d.setDate(d.getDate()+21);const y=d.getFullYear();const m=String(d.getMonth()+1).padStart(2,'0');const dd=String(d.getDate()).padStart(2,'0');console.log(y+'-'+m+'-'+dd)"
+```
+
+CRITICAL: Always use local date component extraction (`getFullYear()`, `getMonth() + 1`, `getDate()`) with padding. NEVER use `toISOString()` — it returns UTC which can produce off-by-one dates for users in timezones ahead of UTC.
+
+If the resolved date is NaN or invalid (check by verifying the output matches YYYY-MM-DD format), print:
+```
+x Invalid date expression: <due_expression>. Use formats like "tomorrow", "next friday", "in 3 days", or YYYY-MM-DD.
+```
+Then stop the workflow. Do NOT fall back to today — the user must correct their date expression.
+
+If the date resolved successfully, store the output as `<due_date>`.
+</step>
+
+<step name="ensure-file">
+Check if `<storage_repo>/donna/follow-ups.md` exists. Use the Read tool to attempt reading it.
+
+If the file does not exist (Read tool returns an error), create it with the Write tool using this content:
+```markdown
+---
+created: <today>
+---
+
+## Follow-ups
+```
+Where `<today>` is today's date in YYYY-MM-DD format.
+
+If the file already exists, continue to the next step.
+</step>
+
+<step name="append-entry">
+Read `<storage_repo>/donna/follow-ups.md` with the Read tool.
+
+Append the follow-up entry on a new line at the end of the file:
+```
+- [ ] <description> | due: <due_date>
+```
+
+Write the updated file back with the Write tool.
+</step>
+
+<step name="git-commit">
+Run via Bash:
+```bash
+node ~/.donna/donna-tools.cjs commit "donna(follow-up): <description>" --files donna/follow-ups.md
+```
+</step>
+
+<step name="confirm">
+Print:
+```
+✓ Follow-up scheduled: <description> (due: <due_date>)
+```
+</step>

package/workflows/relearn-tools.md

@@ -4,82 +4,25 @@
 Check each registered tool's installed version against its stored version and re-learn capabilities for tools that have been updated. Tools at the same version are skipped.
 </objective>
 
-<step name="read-config">
-Read `~/.config/donna/config.md`.
-
-If the file does not exist, print:
-```
-✗ Donna is not configured. Run /donna:setup first.
-```
-Stop.
-
-Extract the `storage_repo`, `daily_folder` (default: `daily`), and `auto_push` (default: false) fields from the YAML frontmatter.
-
-**Obsidian sync:** Check if `<storage_repo>/.obsidian/daily-notes.json` exists.
-- If it exists and has a `folder` field that differs from `<daily_folder>`: update `<daily_folder>` to match Obsidian's value, and update `~/.config/donna/config.md` with the new `daily_folder`. Print `✓ Synced daily folder with Obsidian: <daily_folder>`.
-- If `<storage_repo>/.obsidian/` exists but `daily-notes.json` does not exist or has no `folder` field: write `<storage_repo>/.obsidian/daily-notes.json` with `{"folder":"<daily_folder>"}`. Print `✓ Configured Obsidian daily notes to use <daily_folder>/`.
-- Otherwise: do nothing.
-</step>
-
-<step name="check-pending-migrations">
-Read `~/.donna/state.md` with the Read tool. If the file does not exist or has no `pending_migrations` field in its YAML frontmatter, skip this step.
-
-For each entry in `pending_migrations`:
-
-**`move-standing-files`:** Move standing files from storage repo root to donna/ subfolder.
-
+<step name="init">
 Run via Bash:
 ```bash
-STORAGE_REPO="<storage_repo>"
-DONNA_DIR="$STORAGE_REPO/donna"
-MOVED=0
-
-mkdir -p "$DONNA_DIR"
-for FILE in role.md recurring.md role-research.md; do
-    if [ -f "$STORAGE_REPO/$FILE" ] && [ ! -f "$DONNA_DIR/$FILE" ]; then
-        mv "$STORAGE_REPO/$FILE" "$DONNA_DIR/$FILE"
-        echo "Moved $FILE to donna/$FILE"
-        MOVED=$((MOVED + 1))
-    fi
-done
-
-echo "MOVED=$MOVED"
+INIT=$(node ~/.donna/donna-tools.cjs init)
 ```
 
-If MOVED > 0, commit the move:
-```bash
-git -C <storage_repo> add -A
-git -C <storage_repo> diff --cached --quiet || git -C <storage_repo> commit -m "donna(migrate): move standing files to donna/ subfolder"
+Parse the JSON response. If the `error` field is `"not_configured"`, print:
 ```
-
-If `auto_push` is true in config, also push.
-
-**`backfill-tool-type`:** Backfill `type` on existing tool sections in tools.md using heuristic detection.
-
-Read `<storage_repo>/donna/tools.md` with the Read tool. If the file does not exist or has no tool sections, skip this handler.
-
-For each tool section (starting with `## <tool_name>`), check if a `- type:` line already exists. If the `- type:` line is missing, detect the correct type:
-
-1. If the tool section contains a `- command:` line where the value starts with `mcp:` (e.g., `- command: mcp:linear`), insert `- type: mcp` immediately after the `- command:` line.
-2. Else, if the tool section contains a `- base_url:` line:
-   - If the capabilities section contains entries that look like GraphQL queries (contain `query {` or `mutation {`), insert `- type: graphql` immediately after `## <tool_name>` (REST/GraphQL tools have no `- command:` line).
-   - Otherwise, insert `- type: rest` immediately after `## <tool_name>`.
-3. Else (no `mcp:` prefix, no `base_url` field), insert `- type: cli` immediately after the `- command:` line.
-
-Write the updated file back with the Write tool. If any changes were made, commit:
-```bash
-git -C <storage_repo> add -A
-git -C <storage_repo> diff --cached --quiet || git -C <storage_repo> commit -m "donna(migrate): backfill tool types on existing tools"
+x Donna is not configured. Run /donna:setup first.
 ```
+Stop.
 
-If `auto_push` is true in config, also push.
+Extract `storage_repo`, `daily_folder`, `auto_push` from the JSON.
 
-After processing all pending migrations, update `~/.donna/state.md` with the Write tool: remove the completed entries from `pending_migrations`. If no entries remain, write:
-```markdown
----
-pending_migrations: []
----
+If `update_available` is non-null, print:
+```
+Donna v<update_available> available -- run npx @pingvinen/donna-assistant to update
 ```
+Continue normally.
 </step>
 
 <step name="read-tools-md">
@@ -114,12 +57,16 @@ If `<type>` is `graphql`:
 
   **IMPORTANT: Auth is OPTIONAL for GraphQL tools. Public APIs work without any secret. You MUST always attempt introspection regardless of whether auth is configured. NEVER skip a GraphQL tool just because it has no auth_secret.**
 
-  1. Attempt to read `<storage_repo>/donna/secrets.md` with the Read tool. If the file exists and contains the `auth_secret` key with a value that is not a placeholder (does not contain "REPLACE_WITH"), set `<resolved_secret>` to that value. Otherwise, set `<resolved_secret>` to empty (no auth). **An empty resolved_secret is perfectly valid — proceed to step 2 regardless.**
+  1. Resolve the auth secret via Bash:
+  ```bash
+  node ~/.donna/donna-tools.cjs resolve-secret <auth_secret>
+  ```
+  Parse the JSON response. If `error` is `"key_not_found"` or `"placeholder_value"`, set `<resolved_secret>` to empty (no auth). Otherwise extract the `value` field as `<resolved_secret>`. **An empty resolved_secret is perfectly valid — proceed to step 2 regardless.**
 
-  2. Run via Bash with a 15-second timeout. Include the auth header only when a real secret was resolved:
+  2. Run via Bash with a 15-second timeout (set the Bash tool's `timeout` parameter to `15000`). Include the auth header only when a real secret was resolved:
      - If `<resolved_secret>` is non-empty:
        ```bash
-       timeout 15 curl -s -X POST \
+       curl -s -X POST \
          -H "<auth_header>: <resolved_secret>" \
          -H "Content-Type: application/json" \
          -d '{"query":"{ __schema { types { name fields { name type { name } } } } }"}' \
@@ -127,7 +74,7 @@ If `<type>` is `graphql`:
        ```
      - If `<resolved_secret>` is empty (public API or no secret configured):
        ```bash
-       timeout 15 curl -s -X POST \
+       curl -s -X POST \
          -H "Content-Type: application/json" \
          -d '{"query":"{ __schema { types { name fields { name type { name } } } } }"}' \
          "<base_url>" 2>&1
@@ -232,9 +179,48 @@ Determine if the tool is well-known (gh, jira, kubectl) or unknown. For well-kno
 - list-pods: `kubectl get pods --all-namespaces --field-selector=status.phase!=Succeeded -o wide`
 - list-failing: `kubectl get pods --all-namespaces --field-selector=status.phase=Failed -o wide`
 
-For **unknown tools**, run `<command> --help 2>&1 | head -80` via Bash and use Claude's understanding to identify 3–5 capabilities relevant to daily task management.
+For **unknown tools**, use a cascading approach to re-learn capabilities. Each stage builds on the previous. The goal is to update CLI invocations for existing capability names — do NOT ask the user to re-select capabilities.
+
+**Stage 1 — Local docs:**
+Attempt to find local documentation for the tool:
+```bash
+TOOL_PATH=$(which <command> 2>/dev/null)
+```
+If found, check for README or docs in the tool's package directory:
+```bash
+TOOL_DIR=$(dirname "$(dirname "$TOOL_PATH")")
+ls "$TOOL_DIR"/README* "$TOOL_DIR"/doc* "$TOOL_DIR"/docs* 2>/dev/null | head -5
+```
+If doc files exist, read the entry-point doc (prefer README, then docs/index or equivalent). Then follow internal links, references, or "see also" pointers to sections relevant to the existing capabilities. Use Claude's understanding to navigate — don't stop at a fixed line count.
+
+**Stage 2 — CLI help (baseline):**
+Run `<command> --help 2>&1 | head -80` via Bash. If the help output lists subcommands, also run `<command> <subcommand> --help` for subcommands relevant to existing capabilities. Combine with Stage 1 findings. Update invocations for existing capability names based on any changes to flags, subcommands, or output formats.
+
+**Stage 3 — Web docs (if invocations could not be updated from stages 1-2):**
+If any existing capability's invocation could not be validated from local docs or help output, attempt to fetch the tool's web documentation. Use WebFetch on common doc URLs:
+- `https://<command>.dev` or `https://<command>.io`
+- The homepage URL from `<command> --help` output if one was printed
+
+If a docs page is found, follow links to CLI reference, commands, or API sections rather than reading only the landing page.
+
+**Stage 4 — Source code analysis (user opt-in per D-09):**
+After stages 1-3, if the tool path was found, ask the user:
+
+Use AskUserQuestion:
+```
+Updated <N> capability invocations from docs and help output. Want me to analyze <command>'s source code for additional capabilities?
+```
 
-Do NOT ask the user to re-select capabilities — keep the same capability names, update only the CLI invocations if the training data suggests changes.
+If the user says yes:
+- Read the main entry point (e.g., bin/<command>, cli.js, main.py)
+- Follow imports/requires to command registration, subcommand definitions, or handler modules
+- Navigate into the files that define actual commands and actions — don't stop at the entry point
+- Identify new capabilities from function names, subcommands, or API surface
+- Add any new relevant capabilities to the list
+
+If no: continue with updated invocations.
+
+Do NOT ask the user to re-select capabilities — keep the same capability names, update only the CLI invocations. The cascade's Stage 4 is the only place where NEW capabilities might be added (with user opt-in).
 
 Get the new installed version:
 ```bash
@@ -258,24 +244,7 @@ Write the full file back with the Write tool.
 <step name="git-commit">
 Run via Bash:
 ```bash
-git -C <storage_repo> add -A
-```
-
-Check whether there is anything to commit:
-```bash
-git -C <storage_repo> status --porcelain
-```
-
-If the output is empty, skip the commit and continue.
-
-Otherwise, run:
-```bash
-git -C <storage_repo> commit -m "donna(relearn-tools): updated <count> tool(s)"
-```
-
-If `auto_push` is true in config, also run:
-```bash
-git -C <storage_repo> push
+node ~/.donna/donna-tools.cjs commit "donna(relearn-tools): updated <count> tool(s)" --files donna/tools.md
 ```
 </step>
 

package/workflows/remove-tool.md

@@ -0,0 +1,93 @@
+# Donna Remove-Tool Workflow
+
+<objective>
+Remove a registered tool from tools.md cleanly — confirm with the user, delete the tool's section, and commit.
+</objective>
+
+<step name="init">
+Run via Bash:
+```bash
+INIT=$(node ~/.donna/donna-tools.cjs init)
+```
+
+Parse the JSON response. If the `error` field is `"not_configured"`, print:
+```
+x Donna is not configured. Run /donna:setup first.
+```
+Stop.
+
+Extract `storage_repo`, `daily_folder`, `auto_push` from the JSON.
+
+If `update_available` is non-null, print:
+```
+Donna v<update_available> available -- run npx @pingvinen/donna-assistant to update
+```
+Continue normally.
+</step>
+
+<step name="read-tools-md">
+Read `<storage_repo>/donna/tools.md` with the Read tool. If the file does not exist or has no tool sections, print:
+```
+! No tools registered. Nothing to remove.
+```
+Stop.
+
+Parse each tool section (starting with `## <tool_name>`). For each tool, extract `type`, `command`, `scope`, and the capabilities list.
+
+Store as `<registered_tools>`.
+</step>
+
+<step name="select-tool">
+If a tool name was provided as argument (e.g., `/donna:remove-tool gh`), look it up in `<registered_tools>`. If not found, print `! Tool "<name>" not found in tools.md` and stop.
+
+If no argument was provided, list all registered tools via AskUserQuestion:
+```
+Which tool would you like to remove?
+
+<numbered list of tool names with their type>
+```
+Store the selected tool as `<selected_tool>`.
+</step>
+
+<step name="confirm-removal">
+Display the tool's current configuration summary:
+```
+About to remove <tool_name>:
+
+  type:         <type>
+  command:      <command>
+  scope:        <scope>
+  capabilities: <count> registered
+
+This will delete the tool's entire section from tools.md.
+```
+
+Use AskUserQuestion:
+```
+Remove <tool_name>? (yes/no)
+```
+
+If no, print `Cancelled.` and stop.
+</step>
+
+<step name="remove-from-tools-md">
+Read `<storage_repo>/donna/tools.md`. Remove the entire `## <tool_name>` section (from the `## <tool_name>` heading up to but not including the next `## ` heading, or end of file). Preserve all other tool sections unchanged. Write the full file back with the Write tool.
+
+If no tool sections remain after removal, write the file with just the frontmatter header (preserve any existing frontmatter).
+</step>
+
+<step name="git-commit">
+Run via Bash:
+```bash
+node ~/.donna/donna-tools.cjs commit "donna(remove-tool): removed <tool_name>" --files donna/tools.md
+```
+</step>
+
+<step name="confirm">
+Print:
+```
+! Removed <tool_name> from tools.md
+
+To re-add with a different configuration: /donna:add-tool <tool_name>
+```
+</step>

package/workflows/run-tools.md

@@ -4,82 +4,25 @@
 Execute all configured external tool commands, pull fresh data, and smart-merge results into today's daily file. Does not run the full begin-the-day carry-forward or recurring task logic — this is a mid-day update only.
 </objective>
 
-<step name="read-config">
-Read `~/.config/donna/config.md`.
-
-If the file does not exist, print:
-```
-✗ Donna is not configured. Run /donna:setup first.
-```
-Stop.
-
-Extract the `storage_repo`, `daily_folder` (default: `daily`), and `auto_push` (default: false) fields from the YAML frontmatter.
-
-**Obsidian sync:** Check if `<storage_repo>/.obsidian/daily-notes.json` exists.
-- If it exists and has a `folder` field that differs from `<daily_folder>`: update `<daily_folder>` to match Obsidian's value, and update `~/.config/donna/config.md` with the new `daily_folder`. Print `✓ Synced daily folder with Obsidian: <daily_folder>`.
-- If `<storage_repo>/.obsidian/` exists but `daily-notes.json` does not exist or has no `folder` field: write `<storage_repo>/.obsidian/daily-notes.json` with `{"folder":"<daily_folder>"}`. Print `✓ Configured Obsidian daily notes to use <daily_folder>/`.
-- Otherwise: do nothing.
-</step>
-
-<step name="check-pending-migrations">
-Read `~/.donna/state.md` with the Read tool. If the file does not exist or has no `pending_migrations` field in its YAML frontmatter, skip this step.
-
-For each entry in `pending_migrations`:
-
-**`move-standing-files`:** Move standing files from storage repo root to donna/ subfolder.
-
+<step name="init">
 Run via Bash:
 ```bash
-STORAGE_REPO="<storage_repo>"
-DONNA_DIR="$STORAGE_REPO/donna"
-MOVED=0
-
-mkdir -p "$DONNA_DIR"
-for FILE in role.md recurring.md role-research.md; do
-    if [ -f "$STORAGE_REPO/$FILE" ] && [ ! -f "$DONNA_DIR/$FILE" ]; then
-        mv "$STORAGE_REPO/$FILE" "$DONNA_DIR/$FILE"
-        echo "Moved $FILE to donna/$FILE"
-        MOVED=$((MOVED + 1))
-    fi
-done
-
-echo "MOVED=$MOVED"
+INIT=$(node ~/.donna/donna-tools.cjs init)
 ```
 
-If MOVED > 0, commit the move:
-```bash
-git -C <storage_repo> add -A
-git -C <storage_repo> diff --cached --quiet || git -C <storage_repo> commit -m "donna(migrate): move standing files to donna/ subfolder"
+Parse the JSON response. If the `error` field is `"not_configured"`, print:
 ```
-
-If `auto_push` is true in config, also push.
-
-**`backfill-tool-type`:** Backfill `type` on existing tool sections in tools.md using heuristic detection.
-
-Read `<storage_repo>/donna/tools.md` with the Read tool. If the file does not exist or has no tool sections, skip this handler.
-
-For each tool section (starting with `## <tool_name>`), check if a `- type:` line already exists. If the `- type:` line is missing, detect the correct type:
-
-1. If the tool section contains a `- command:` line where the value starts with `mcp:` (e.g., `- command: mcp:linear`), insert `- type: mcp` immediately after the `- command:` line.
-2. Else, if the tool section contains a `- base_url:` line:
-   - If the capabilities section contains entries that look like GraphQL queries (contain `query {` or `mutation {`), insert `- type: graphql` immediately after `## <tool_name>` (REST/GraphQL tools have no `- command:` line).
-   - Otherwise, insert `- type: rest` immediately after `## <tool_name>`.
-3. Else (no `mcp:` prefix, no `base_url` field), insert `- type: cli` immediately after the `- command:` line.
-
-Write the updated file back with the Write tool. If any changes were made, commit:
-```bash
-git -C <storage_repo> add -A
-git -C <storage_repo> diff --cached --quiet || git -C <storage_repo> commit -m "donna(migrate): backfill tool types on existing tools"
+x Donna is not configured. Run /donna:setup first.
 ```
+Stop.
 
-If `auto_push` is true in config, also push.
+Extract `storage_repo`, `daily_folder`, `auto_push` from the JSON.
 
-After processing all pending migrations, update `~/.donna/state.md` with the Write tool: remove the completed entries from `pending_migrations`. If no entries remain, write:
-```markdown
----
-pending_migrations: []
----
+If `update_available` is non-null, print:
 ```
+Donna v<update_available> available -- run npx @pingvinen/donna-assistant to update
+```
+Continue normally.
 </step>
 
 <step name="read-tools-md">
@@ -95,13 +38,11 @@ Store the parsed tools and their capabilities as `<registered_tools>`.
 </step>
 
 <step name="find-daily-file">
-Get today's date via Bash:
+Get the daily file path via donna-tools:
 ```bash
-date +%Y-%m-%d
+DAILY_PATH=$(node ~/.donna/donna-tools.cjs daily-path | node -e "process.stdin.resume();let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>console.log(JSON.parse(d).path))")
 ```
-Store as `<today>`.
-
-Construct the path: `<storage_repo>/<daily_folder>/<today>.md`.
+Store the result as `<daily_file_path>`. Extract `<today>` from the filename (last path component without `.md`).
 
 If the file does not exist, print:
 ```
@@ -143,9 +84,9 @@ If the `## From Tools` section does not exist in today's file, set `<existing_to
 
 For `type: cli` capabilities (format: `<name>: <cli_invocation>`):
 
-Run the capability command via Bash with a 10-second timeout:
+Run the capability command via Bash (set the Bash tool's `timeout` parameter to `10000`):
 ```bash
-timeout 10 <capability_command> 2>&1
+<capability_command> 2>&1
 ```
 
 **On success (exit 0):** Parse the output into task entries. Every task line MUST include both a tool tag and a descriptive link.
@@ -174,11 +115,14 @@ For other tools: use Claude's understanding to extract task-like items from the
 Continue to the next capability. Never retry.
 
 For `type: rest` capabilities (format: `<name>: <METHOD> /path`):
-1. Read `<storage_repo>/donna/secrets.md` with the Read tool. Parse key-value pairs from under the frontmatter.
-2. Resolve the `auth_secret` key to get the actual secret value. If the key is not found in secrets.md or the value is `REPLACE_WITH_YOUR_SECRET`, add warning `! <tool_name>: missing secret <auth_secret> — edit donna/secrets.md` and skip this tool.
-3. For each capability, run via Bash with a 10-second timeout:
+1. Resolve the auth secret via Bash:
 ```bash
-timeout 10 curl -s -H "<auth_header>: <resolved_secret>" "<base_url><path>" 2>&1
+node ~/.donna/donna-tools.cjs resolve-secret <auth_secret>
+```
+2. Parse the JSON response. If `error` is `"key_not_found"` or `"placeholder_value"`, add warning `! <tool_name>: missing secret <auth_secret> — edit donna/secrets.md` and skip this tool. Otherwise extract the `value` field as `<resolved_secret>`.
+3. For each capability, run via Bash (set the Bash tool's `timeout` parameter to `10000`):
+```bash
+curl -s -H "<auth_header>: <resolved_secret>" "<base_url><path>" 2>&1
 ```
 4. Parse the JSON response using Claude's understanding to extract task-like items. Format:
 `- [ ] (<tool_name>) <description> [<identifier>](<url>)`
@@ -189,9 +133,9 @@ Continue. Never retry.
 
 For `type: graphql` capabilities (format: `<name>: <graphql_query>`):
 1. Same secrets resolution as REST.
-2. For each capability, run via Bash with a 10-second timeout:
+2. For each capability, run via Bash (set the Bash tool's `timeout` parameter to `10000`):
 ```bash
-timeout 10 curl -s -X POST -H "<auth_header>: <resolved_secret>" -H "Content-Type: application/json" -d '{"query":"<graphql_query>"}' "<base_url>" 2>&1
+curl -s -X POST -H "<auth_header>: <resolved_secret>" -H "Content-Type: application/json" -d '{"query":"<graphql_query>"}' "<base_url>" 2>&1
 ```
 3. Parse the JSON response to extract task-like items. Same format as REST.
 
@@ -223,7 +167,7 @@ For each URL in `<existing_tool_lines>`:
 1. If the line is `[x]` (user manually checked): **KEEP AS-IS** — user intent wins (Rule 1). Do not change regardless of tool state.
 2. If the line is `[ ]` AND the URL exists in `<fresh_tool_tasks>`: **KEEP OPEN** — item is still active (Rule 2).
 3. If the line is `[ ]` AND the URL is NOT in `<fresh_tool_tasks>`: the item was removed from the tool (reassigned, deleted, or closed).
-   - For gh items: check if the PR/issue was closed or merged via Bash: `timeout 10 gh pr view <number> --json state --jq '.state' 2>/dev/null || timeout 10 gh issue view <number> --json state --jq '.state' 2>/dev/null`
+   - For gh items: check if the PR/issue was closed or merged via Bash (set the Bash tool's `timeout` parameter to `10000`): `gh pr view <number> --json state --jq '.state' 2>/dev/null || gh issue view <number> --json state --jq '.state' 2>/dev/null`
    - If closed or merged: change to `- [x] (<tool>) <description> [<identifier>](<url>) (<reason>)` and move to `## Resolved` (Rule 3a).
    - If status check fails or item simply no longer appears: move to `## Resolved` with `(removed)` (Rule 3b).
 
@@ -244,24 +188,7 @@ If `## From Tools` does not yet exist in the file, add it after the `## Tasks` s
 <step name="git-commit">
 Run via Bash:
 ```bash
-git -C <storage_repo> add -A
-```
-
-Check whether there is anything to commit:
-```bash
-git -C <storage_repo> status --porcelain
-```
-
-If the output is empty, skip the commit and continue.
-
-Otherwise, run:
-```bash
-git -C <storage_repo> commit -m "donna(run-tools): refreshed tool data for <today>"
-```
-
-If `auto_push` is true in config, also run:
-```bash
-git -C <storage_repo> push
+node ~/.donna/donna-tools.cjs commit "donna(tools): refreshed tool data" --files <daily_folder>/<today>.md
 ```
 </step>