get-claudia 1.42.4 → 1.44.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-claudia",
-  "version": "1.42.4",
+  "version": "1.44.0",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",

package/template-v2/.claude/skills/README.md

@@ -133,6 +133,7 @@ argument-hint: [arg]
 | `commitment-detector.md` | Catches promises | "I'll...", deadlines |
 | `pattern-recognizer.md` | Notices trends | Recurring themes |
 | `risk-surfacer.md` | Warns about issues | Overdue, cooling |
+| `judgment-awareness.md` | Applies business judgment rules | Priority conflicts, escalation |
 | `capability-suggester.md` | Suggests new skills | Repeated behaviors |
 | `memory-manager.md` | Session persistence | Session start/end |
 
@@ -194,7 +195,7 @@ effort-level: medium
 
 | Effort | Skills |
 |--------|--------|
-| **low** | morning-brief, client-health, financial-snapshot, growth-check, databases, diagnose, brain-monitor, inbox-check |
+| **low** | morning-brief, client-health, financial-snapshot, growth-check, databases, diagnose, brain-monitor, inbox-check, judgment-awareness |
 | **medium** | meeting-prep, draft-reply, follow-up-draft, file-document, new-person, capture-meeting, summarize-doc, memory-audit, brain, fix-duplicates, memory-health, memory-manager, onboarding, structure-generator, agent-dispatcher, new-workspace |
 | **high** | weekly-review, meditate, research, what-am-i-missing, map-connections, commitment-detector, capability-suggester, concierge, connector-discovery, pattern-recognizer, relationship-tracker, risk-surfacer, structure-evolution, hire-agent |
 | **max** | ingest-sources, pipeline-review, deep-context |

package/template-v2/.claude/skills/agent-dispatcher.md

@@ -2,6 +2,7 @@
 name: agent-dispatcher
 description: Detects when to delegate tasks to specialized agents. Core dispatch logic with two-tier dispatch.
 user-invocable: false
+invocation: proactive
 effort-level: medium
 ---
 

package/template-v2/.claude/skills/commitment-detector.md

@@ -96,6 +96,12 @@ outputs:
 
    This ensures the commitment survives context compaction and can be recalled semantically. Do not skip this step.
 
+3b. **Check judgment rules** - If `context/judgment.yaml` exists and has `escalation` rules matching this entity or commitment type, boost importance accordingly:
+   - Matching escalation rule: boost importance to 0.95
+   - Matching escalation rule with "immediate" or "critical" language: boost to 1.0
+   - Matching priority rank 1: boost to 0.95
+   - Never reduce importance below the standard 0.9 for commitments
+
 4. **Add to context/commitments.md**
 
 5. **Link to person file if relevant**

package/template-v2/.claude/skills/hire-agent.md

@@ -2,6 +2,7 @@
 name: hire-agent
 description: Suggests new agents based on repeated task patterns.
 user-invocable: false
+invocation: proactive
 effort-level: high
 ---
 

package/template-v2/.claude/skills/judgment-awareness.md

@@ -0,0 +1,234 @@
+---
+name: judgment-awareness
+description: Load and apply user-defined judgment rules from context/judgment.yaml to inform priority conflicts, escalation decisions, surfacing, and delegation.
+user-invocable: false
+invocation: proactive
+effort-level: low
+triggers:
+  - "priority conflict between tasks"
+  - "should I escalate this"
+  - "which commitment matters more"
+  - "delegation decision needed"
+  - "what to surface in brief"
+inputs:
+  - name: judgment_rules
+    type: file
+    description: context/judgment.yaml containing user-defined decision boundary rules
+outputs:
+  - name: informed_decision
+    type: text
+    description: Decision informed by judgment rules with provenance citation
+---
+
+# Judgment Awareness Skill
+
+**Triggers:** Activates at session start (after `memory.briefing`) and during any priority conflict, escalation decision, surfacing choice, or delegation routing.
+
+---
+
+## Purpose
+
+Users accumulate business judgment over time: which clients matter most, when to break standard behavior, what always needs surfacing. This skill loads those judgment rules from `context/judgment.yaml` and applies them contextually across all other skills.
+
+**This is not a rules engine.** Rules use natural language conditions that I interpret contextually, the same way I interpret `claudia-principles.md`. The file encodes the user's business trade-offs, not programmatic logic.
+
+---
+
+## Rule Hierarchy
+
+```
+claudia-principles.md        ← Immutable. Safety First is non-negotiable.
+  └── trust-north-star.md    ← Provenance and honesty requirements.
+        └── judgment.yaml    ← User's business trade-offs and preferences.
+              └── reflections ← Session-learned preferences (lowest priority).
+```
+
+**A judgment rule can NEVER:**
+- Override Safety First (Principle 1)
+- Skip approval for external actions
+- Reduce Trust North Star requirements
+- Contradict claudia-principles.md
+
+If a judgment rule conflicts with a principle, the principle wins silently.
+
+---
+
+## Loading Rules
+
+### At Session Start
+
+After calling `memory.briefing`, silently check for `context/judgment.yaml`:
+
+1. If the file exists, read it and hold the rules in context
+2. If the file does not exist, continue normally (graceful degradation)
+3. Never narrate the loading process. Never mention judgment.yaml to the user unless they ask about it
+
+### File Format
+
+```yaml
+version: 1
+
+priorities:        # When tasks conflict, use this ordering
+  - label: "Client deliverables"
+    rank: 1
+    note: "Always prioritize active client work over internal tasks"
+
+escalation:        # When to always surface something
+  - id: esc-001
+    when: "Commitments involving Sarah Chen"
+    condition: "Within 72 hours of deadline"
+    action: "Surface immediately in any session, not just morning brief"
+    source: "meditate/2026-02-25"
+
+overrides:         # When to break standard behavior
+  - id: ovr-001
+    when: "Investor emails from Series A leads"
+    action: "Boost to top of morning brief regardless of other priorities"
+    source: "manual"
+
+surfacing:         # What to always bring up
+  - id: srf-001
+    trigger: "morning_brief"
+    what: "Open proposals older than 5 business days"
+    why: "Stale proposals signal lost deals"
+    source: "meditate/2026-02-20"
+
+delegation:        # What to auto-delegate vs escalate
+  - id: del-001
+    task_type: "Meeting transcript processing"
+    action: "Auto-delegate to Document Processor"
+    exception: "Unless it involves board members"
+    source: "meditate/2026-02-18"
+```
+
+### Rule Fields
+
+| Field | Required | Purpose |
+|-------|----------|---------|
+| `id` | Yes (except priorities) | Unique identifier for editing/removing |
+| `when` / `trigger` | Yes | Natural language condition |
+| `action` / `what` | Yes | What to do when condition matches |
+| `condition` | No | Additional qualifying context |
+| `source` | Yes | Provenance: `meditate/YYYY-MM-DD` or `manual` |
+| `note` / `why` | No | Reasoning for the rule |
+
+---
+
+## Applying Rules
+
+### During Priority Conflicts
+
+When two tasks or commitments compete for attention:
+
+1. Check `priorities` rules for ordering guidance
+2. Check `escalation` rules for any entity-specific boosts
+3. If rules conflict with each other, surface both to the user:
+   ```
+   Your judgment rules create a conflict here:
+   - Rule esc-001 says to prioritize Sarah's deadline
+   - Rule priorities rank 1 says client deliverables come first
+
+   Which takes precedence in this case?
+   ```
+4. If no rules apply, fall back to standard importance scoring
+
+### During Escalation Decisions
+
+When deciding severity or urgency:
+
+1. Check `escalation` rules for entity or condition matches
+2. Matching rules can boost severity (Watch -> Warning -> Critical)
+3. Rules can NEVER reduce severity below what standard logic determines
+4. Apply the boost, cite the rule internally (don't narrate unless asked)
+
+### During Surfacing
+
+When building morning briefs, session greetings, or proactive alerts:
+
+1. Check `surfacing` rules for trigger matches (`session_start`, `morning_brief`)
+2. Add matching items to the appropriate output section
+3. Use `priorities` to order items when there are conflicts
+4. Check `overrides` for items that should jump the queue
+
+### During Delegation
+
+When the agent-dispatcher skill routes tasks:
+
+1. Check `delegation` rules for task type matches
+2. Apply the routing preference (auto-delegate vs escalate)
+3. Check for exceptions before auto-delegating
+4. When in doubt, escalate to the user rather than auto-delegate
+
+---
+
+## Integration Touchpoints
+
+| Skill | How Judgment Rules Affect It |
+|-------|------------------------------|
+| Morning Brief | `surfacing` rules add items; `priorities` order them |
+| Commitment Detector | `escalation` rules boost importance of entity-linked commitments |
+| Risk Surfacer | `escalation` rules can raise severity (Watch -> Warning -> Critical) |
+| Agent Dispatcher | `delegation` rules modify auto-dispatch decisions |
+| What Am I Missing | `priorities` weight the risk assessment |
+| Meeting Prep | `escalation` rules flag high-priority relationships |
+| Weekly Review | `priorities` inform the "what matters most" framing |
+
+---
+
+## Handling Edge Cases
+
+### Stale Rules
+
+If a rule's `source` date is older than 90 days, flag it during the next `/meditate` session:
+
+```
+I noticed a judgment rule from 3 months ago:
+  esc-001: "Always surface commitments to Sarah Chen within 72h"
+
+Is this still relevant, or should I remove it?
+```
+
+### Conflicting Rules
+
+When two rules point in different directions, always surface both to the user. Never silently pick one.
+
+### Missing File
+
+If `context/judgment.yaml` doesn't exist, all skills operate normally using their standard logic. The judgment layer is purely additive.
+
+### Malformed YAML
+
+If the file exists but has syntax errors, warn the user once per session:
+```
+I noticed a formatting issue in your judgment rules file.
+I'll use standard logic until it's fixed. Want me to take a look?
+```
+
+---
+
+## What This Skill Does NOT Do
+
+- **No autonomous rule creation.** Rules are only added via `/meditate` with user approval or manual editing
+- **No principle overrides.** Safety First, approval flows, and Trust North Star are immutable
+- **No silent rule application on external actions.** Judgment rules inform internal prioritization only. Any external action still requires explicit approval per Principle 1
+- **No narration.** I don't mention judgment rules in normal conversation unless the user asks
+
+---
+
+## User Control
+
+Users can always:
+- Edit `context/judgment.yaml` directly in any text editor
+- Ask "what judgment rules do you have?" to see current rules
+- Ask "remove rule esc-001" to delete a specific rule
+- Say "ignore that rule for now" to temporarily bypass a rule in the current session
+
+---
+
+## Tone
+
+When judgment rules influence a decision, I don't announce it. I just make better decisions. If asked why I prioritized something, I can cite the rule:
+
+"You told me investor communications always come first, so I led with that."
+
+The goal is invisible intelligence, not visible process.

package/template-v2/.claude/skills/meditate/SKILL.md

@@ -69,6 +69,15 @@ Review the session and identify 1-3 reflections. Ask yourself:
    - Things the user mentioned but didn't pursue
    - Context that would be helpful to have
 
+5. **Did any judgment-relevant decisions happen this session?**
+   - Did the user override a default behavior? (e.g., "Actually, always put investor stuff first")
+   - Did the user establish a priority? (e.g., "Client work always comes before internal ops")
+   - Did the user correct my escalation behavior? (e.g., "You should have flagged that sooner")
+   - Did the user set a delegation preference? (e.g., "Just auto-process meeting transcripts")
+   - Did the user reveal a surfacing preference? (e.g., "Always remind me about stale proposals")
+
+   If yes, draft a judgment rule for each (see Step 3). Not every session produces judgment rules. Most won't. Only propose rules when behavior clearly indicates a repeatable business trade-off.
+
 **Quality over quantity.** One genuine insight beats three generic observations.
 
 ### Step 3: Present for Approval
@@ -92,18 +101,53 @@ Today we [brief 1-2 sentence summary of what happened].
 ---
 ```
 
+If judgment-relevant decisions were identified in question 5, append proposed rules after the reflections:
+
+```
+**Proposed Judgment Rules:**
+
+4. **Rule (escalation):** Always surface commitments to Sarah Chen within 72h of deadline
+   - *Based on:* You checked on the Sarah proposal three times this session
+   - *Category:* escalation
+
+5. **Rule (priorities):** Client deliverables always take precedence over internal ops
+   - *Based on:* You explicitly said "client work first, always"
+   - *Category:* priorities
+
+*These would be saved to your judgment rules file so I apply them in future sessions.*
+*Say "looks good" to save everything, or tell me what to adjust.*
+
+---
+```
+
+Only propose rules when the evidence is clear. A single offhand comment is not enough. Look for:
+- Explicit statements of priority or preference
+- Repeated behavior (checked something 3+ times)
+- Direct corrections of my default behavior
+- Clear delegation instructions
+
 ### Step 4: Handle Edits
 
 User responses:
 
 | Response | Action |
 |----------|--------|
-| "Looks good" / "Save it" | Store all reflections |
+| "Looks good" / "Save it" | Store all reflections and approved judgment rules |
 | "Remove the second one" | Delete that reflection, store others |
 | "That's not quite right about X" | Edit that reflection, then confirm |
 | "Skip" / "Don't save anything" | End without storing |
 | User provides correction | Update the reflection content |
 
+**Judgment rule responses:**
+
+| Response | Action |
+|----------|--------|
+| "Remove the rule" | Store reflections only, skip the judgment rule |
+| "Make it broader" | Generalize the rule (e.g., "Sarah" -> "all key clients"), re-confirm |
+| "That should apply to all clients" | Widen scope of the rule, re-confirm |
+| "Make it narrower" | Restrict the rule scope, re-confirm |
+| "Save the reflections but not the rules" | Store reflections, skip all judgment rules |
+
 ### Step 5: Store and Close
 
 Call `memory.end_session` with:
@@ -111,7 +155,28 @@ Call `memory.end_session` with:
 - `reflections`: Array of approved reflections with type, content, and optional about fields
 - Other structured extractions (facts, commitments, entities) as needed
 
-Confirm storage: "Got it, I'll keep that in mind. See you next time."
+**If judgment rules were approved**, also write them to `context/judgment.yaml`:
+
+1. Read `context/judgment.yaml` (if it exists)
+2. If the file doesn't exist, create it with the initial structure:
+   ```yaml
+   version: 1
+
+   priorities: []
+   escalation: []
+   overrides: []
+   surfacing: []
+   delegation: []
+   ```
+3. Append each approved rule to the appropriate category
+4. Assign a sequential ID within its category (e.g., `esc-001`, `esc-002`)
+5. Set `source` to `meditate/YYYY-MM-DD` (today's date)
+6. Write the updated file
+
+Confirm storage with both reflections and rules:
+"Got it. I've saved [N] reflection(s) and added [M] judgment rule(s) to your judgment file. I'll apply them going forward. See you next time."
+
+If only reflections (no rules): "Got it, I'll keep that in mind. See you next time."
 
 ---
 
@@ -200,6 +265,10 @@ Claudia:
 
 ## Integration with Other Skills
 
+### Judgment Rules
+
+The meditate skill is the primary mechanism for creating judgment rules. When session behavior reveals business trade-offs, priorities, or preferences, meditate proposes rules that get saved to `context/judgment.yaml`. See the `judgment-awareness` skill for how rules are loaded and applied.
+
 ### Morning Brief
 
 When generating morning brief, pull relevant reflections:
@@ -305,3 +374,32 @@ Quick session today. Reviewed the proposal draft and made some edits.
 
 ---
 ```
+
+### Example 4: Session with judgment-relevant behavior
+
+```
+---
+**Session Reflection**
+
+Today we triaged a busy week and you reorganized your priorities after that unexpected investor call.
+
+**What I'm taking away:**
+
+1. **Learning:** When investor communications arrive, you drop everything else to respond. Speed matters more than polish for these.
+2. **Observation:** You checked on the Acme proposal status three times unprompted. That one's weighing on you.
+
+**Proposed Judgment Rules:**
+
+3. **Rule (priorities):** Investor communications take precedence over all other tasks
+   - *Based on:* You explicitly said "investors always come first" and reorganized your entire day around the call
+   - *Category:* priorities
+
+4. **Rule (escalation):** Surface Acme proposal status in every session until it's resolved
+   - *Based on:* You checked on it three times without me prompting
+   - *Category:* surfacing
+
+*These would be saved to your judgment rules file so I apply them in future sessions.*
+*Do these feel accurate? Say "looks good" to save, or tell me what to adjust.*
+
+---
+```

package/template-v2/.claude/skills/memory-manager.md

@@ -2,6 +2,7 @@
 name: memory-manager
 description: Handle cross-session persistence using the enhanced memory system (MCP) with fallback to markdown files.
 user-invocable: false
+invocation: proactive
 effort-level: medium
 ---
 

package/template-v2/.claude/skills/morning-brief/SKILL.md

@@ -22,6 +22,14 @@ Provide a concise morning brief to start the day with clarity. Surface what matt
 
 2. **Call `memory.recall`** for specific follow-up queries as needed
 
+### Judgment Rules (if available)
+
+3. **Check `context/judgment.yaml`** for surfacing rules with `trigger: "morning_brief"`
+   - Add matching items to the appropriate brief section
+   - Use `priorities` rules to order items when there are conflicts
+   - Check `overrides` rules for items that should jump to the top regardless of standard ordering
+   - Check `escalation` rules to boost severity of entity-linked items
+
 ### Markdown Fallback
 
 Use `context/commitments.md`, `context/waiting.md`, and `people/` files.

package/template-v2/.claude/skills/onboarding.md

@@ -2,6 +2,7 @@
 name: onboarding
 description: Guide new users through a conversational discovery flow to create a personalized Claudia setup.
 user-invocable: false
+invocation: proactive
 effort-level: medium
 ---
 

package/template-v2/.claude/skills/risk-surfacer.md

@@ -166,6 +166,19 @@ End each alert block (or group of alerts) with a trailing horizontal rule to vis
 
 ---
 
+## Judgment-Informed Severity
+
+When `context/judgment.yaml` exists and has relevant rules:
+
+- **Escalation rules** matching an entity or condition boost severity by one level (Watch -> Warning -> Critical)
+- **Override rules** can adjust thresholds for specific entities (e.g., "always treat investor items as Warning or above")
+- **Priority rules** influence which risks get surfaced first when multiple are active
+- **Never reduce severity** below what standard logic determines. Judgment rules are additive only.
+
+When a judgment rule influences severity, note it internally for provenance but don't narrate it unless the user asks why something was escalated.
+
+---
+
 ## Risk Detection Logic
 
 ### Commitment Analysis

package/template-v2/.claude/skills/skill-index.json

@@ -34,6 +34,14 @@
       "effort_level": "medium",
       "triggers": ["delegate task", "use agent team", "process document", "research task"]
     },
+    {
+      "name": "judgment-awareness",
+      "path": "judgment-awareness.md",
+      "description": "Load and apply user-defined judgment rules from context/judgment.yaml to inform priority conflicts, escalation decisions, surfacing, and delegation",
+      "invocation": "proactive",
+      "effort_level": "low",
+      "triggers": ["priority conflict", "which task matters more", "escalation decision", "what to surface first"]
+    },
     {
       "name": "commitment-detector",
       "path": "commitment-detector.md",

package/template-v2/.claude/skills/structure-generator.md

@@ -2,6 +2,7 @@
 name: structure-generator
 description: Create personalized folder structures and files based on user archetype, business depth preferences, and workflow needs.
 user-invocable: false
+invocation: proactive
 effort-level: medium
 ---
 
@@ -1427,6 +1428,139 @@ When generating a structure:
 
 ---
 
+## Optional Judgment Rule Templates
+
+During onboarding or later sessions, if the user wants help setting up initial judgment rules, offer archetype-specific starter priorities. These are created in `context/judgment.yaml` only when explicitly requested.
+
+**When to offer:** After structure setup is complete, if the user asks about priorities, or if during `/meditate` the user wants a starting framework. Never create this file automatically.
+
+### Consultant/Advisor Starter Rules
+
+```yaml
+version: 1
+
+priorities:
+  - label: "Client deliverables"
+    rank: 1
+    note: "Active client work always comes first"
+  - label: "Prospect follow-ups"
+    rank: 2
+    note: "Pipeline health depends on timely responses"
+  - label: "Internal operations"
+    rank: 3
+    note: "Invoicing, admin, process improvement"
+  - label: "Business development content"
+    rank: 4
+    note: "Thought leadership, networking, speaking"
+
+escalation: []
+overrides: []
+surfacing: []
+delegation: []
+```
+
+### Founder/Entrepreneur Starter Rules
+
+```yaml
+version: 1
+
+priorities:
+  - label: "Investor communications"
+    rank: 1
+    note: "Speed and responsiveness signal competence to investors"
+  - label: "Product-blocking decisions"
+    rank: 2
+    note: "Unblock the team before anything else"
+  - label: "Team management"
+    rank: 3
+    note: "1:1s, hiring, culture"
+  - label: "Operational tasks"
+    rank: 4
+    note: "Admin, legal, finance"
+
+escalation: []
+overrides: []
+surfacing: []
+delegation: []
+```
+
+### Executive/Manager Starter Rules
+
+```yaml
+version: 1
+
+priorities:
+  - label: "Board and leadership commitments"
+    rank: 1
+    note: "Upward obligations have the least flexibility"
+  - label: "Direct report 1:1s and development"
+    rank: 2
+    note: "People management is the multiplier"
+  - label: "Cross-functional initiatives"
+    rank: 3
+    note: "Strategic projects and collaboration"
+  - label: "Administrative tasks"
+    rank: 4
+    note: "Expense reports, scheduling, documentation"
+
+escalation: []
+overrides: []
+surfacing: []
+delegation: []
+```
+
+### Solo Professional Starter Rules
+
+```yaml
+version: 1
+
+priorities:
+  - label: "Client deliverables"
+    rank: 1
+    note: "Reputation is everything when you're solo"
+  - label: "Overdue invoices"
+    rank: 2
+    note: "Cash flow is survival"
+  - label: "New client onboarding"
+    rank: 3
+    note: "First impressions set the relationship"
+  - label: "Professional development"
+    rank: 4
+    note: "Skills keep you competitive"
+
+escalation: []
+overrides: []
+surfacing: []
+delegation: []
+```
+
+### Content Creator Starter Rules
+
+```yaml
+version: 1
+
+priorities:
+  - label: "Sponsored content deadlines"
+    rank: 1
+    note: "Paid commitments with contractual obligations"
+  - label: "Content calendar"
+    rank: 2
+    note: "Consistency builds audience trust"
+  - label: "Collaboration responses"
+    rank: 3
+    note: "Relationships with other creators open doors"
+  - label: "Audience engagement"
+    rank: 4
+    note: "Comments, DMs, community management"
+
+escalation: []
+overrides: []
+surfacing: []
+delegation: []
+```
+
+---
+
 ## Handling Customization
 
 If user requests modifications: