niahere 0.2.34 → 0.2.36

package/skills/pricing-strategy/SKILL.md

@@ -0,0 +1,231 @@
+---
+name: pricing-strategy
+description: "When the user wants help with pricing decisions, packaging, or monetization strategy. Also use when the user mentions 'pricing,' 'pricing tiers,' 'freemium,' 'free trial,' 'packaging,' 'price increase,' 'value metric,' 'Van Westendorp,' 'willingness to pay,' 'monetization,' 'how much should I charge,' 'my pricing is wrong,' 'pricing page,' 'annual vs monthly,' 'per seat pricing,' or 'should I offer a free plan.' Use this whenever someone is figuring out what to charge or how to structure their plans. For in-app upgrade screens, see paywall-upgrade-cro."
+metadata:
+  version: 1.1.0
+---
+
+# Pricing Strategy
+
+You are an expert in SaaS pricing and monetization strategy. Your goal is to help design pricing that captures value, drives growth, and aligns with customer willingness to pay.
+
+## Before Starting
+
+**Check for product marketing context first:**
+If `.agents/product-marketing-context.md` exists (or `.claude/product-marketing-context.md` in older setups), read it before asking questions. Use that context and only ask for information not already covered or specific to this task.
+
+Gather this context (ask if not provided):
+
+### 1. Business Context
+- What type of product? (SaaS, marketplace, e-commerce, service)
+- What's your current pricing (if any)?
+- What's your target market? (SMB, mid-market, enterprise)
+- What's your go-to-market motion? (self-serve, sales-led, hybrid)
+
+### 2. Value & Competition
+- What's the primary value you deliver?
+- What alternatives do customers consider?
+- How do competitors price?
+
+### 3. Current Performance
+- What's your current conversion rate?
+- What's your ARPU and churn rate?
+- Any feedback on pricing from customers/prospects?
+
+### 4. Goals
+- Optimizing for growth, revenue, or profitability?
+- Moving upmarket or expanding downmarket?
+
+---
+
+## Pricing Fundamentals
+
+### The Three Pricing Axes
+
+**1. Packaging** — What's included at each tier?
+- Features, limits, support level
+- How tiers differ from each other
+
+**2. Pricing Metric** — What do you charge for?
+- Per user, per usage, flat fee
+- How price scales with value
+
+**3. Price Point** — How much do you charge?
+- The actual dollar amounts
+- Perceived value vs. cost
+
+### Value-Based Pricing
+
+Price should be based on value delivered, not cost to serve:
+
+- **Customer's perceived value** — The ceiling
+- **Your price** — Between alternatives and perceived value
+- **Next best alternative** — The floor for differentiation
+- **Your cost to serve** — Only a baseline, not the basis
+
+**Key insight:** Price between the next best alternative and perceived value.
+
+---
+
+## Value Metrics
+
+### What is a Value Metric?
+
+The value metric is what you charge for—it should scale with the value customers receive.
+
+**Good value metrics:**
+- Align price with value delivered
+- Are easy to understand
+- Scale as customer grows
+- Are hard to game
+
+### Common Value Metrics
+
+| Metric | Best For | Example |
+|--------|----------|---------|
+| Per user/seat | Collaboration tools | Slack, Notion |
+| Per usage | Variable consumption | AWS, Twilio |
+| Per feature | Modular products | HubSpot add-ons |
+| Per contact/record | CRM, email tools | Mailchimp |
+| Per transaction | Payments, marketplaces | Stripe |
+| Flat fee | Simple products | Basecamp |
+
+### Choosing Your Value Metric
+
+Ask: "As a customer uses more of [metric], do they get more value?"
+- If yes → good value metric
+- If no → price doesn't align with value
+
+---
+
+## Tier Structure Overview
+
+### Good-Better-Best Framework
+
+**Good tier (Entry):** Core features, limited usage, low price
+**Better tier (Recommended):** Full features, reasonable limits, anchor price
+**Best tier (Premium):** Everything, advanced features, 2-3x Better price
+
+### Tier Differentiation
+
+- **Feature gating** — Basic vs. advanced features
+- **Usage limits** — Same features, different limits
+- **Support level** — Email → Priority → Dedicated
+- **Access** — API, SSO, custom branding
+
+**For detailed tier structures and persona-based packaging**: See [references/tier-structure.md](references/tier-structure.md)
+
+---
+
+## Pricing Research
+
+### Van Westendorp Method
+
+Four questions that identify acceptable price range:
+1. Too expensive (wouldn't consider)
+2. Too cheap (question quality)
+3. Expensive but might consider
+4. A bargain
+
+Analyze intersections to find optimal pricing zone.
+
+### MaxDiff Analysis
+
+Identifies which features customers value most:
+- Show sets of features
+- Ask: Most important? Least important?
+- Results inform tier packaging
+
+**For detailed research methods**: See [references/research-methods.md](references/research-methods.md)
+
+---
+
+## When to Raise Prices
+
+### Signs It's Time
+
+**Market signals:**
+- Competitors have raised prices
+- Prospects don't flinch at price
+- "It's so cheap!" feedback
+
+**Business signals:**
+- Very high conversion rates (>40%)
+- Very low churn (<3% monthly)
+- Strong unit economics
+
+**Product signals:**
+- Significant value added since last pricing
+- Product more mature/stable
+
+### Price Increase Strategies
+
+1. **Grandfather existing** — New price for new customers only
+2. **Delayed increase** — Announce 3-6 months out
+3. **Tied to value** — Raise price but add features
+4. **Plan restructure** — Change plans entirely
+
+---
+
+## Pricing Page Best Practices
+
+### Above the Fold
+- Clear tier comparison table
+- Recommended tier highlighted
+- Monthly/annual toggle
+- Primary CTA for each tier
+
+### Common Elements
+- Feature comparison table
+- Who each tier is for
+- FAQ section
+- Annual discount callout (17-20%)
+- Money-back guarantee
+- Customer logos/trust signals
+
+### Pricing Psychology
+- **Anchoring:** Show higher-priced option first
+- **Decoy effect:** Middle tier should be best value
+- **Charm pricing:** $49 vs. $50 (for value-focused)
+- **Round pricing:** $50 vs. $49 (for premium)
+
+---
+
+## Pricing Checklist
+
+### Before Setting Prices
+- [ ] Defined target customer personas
+- [ ] Researched competitor pricing
+- [ ] Identified your value metric
+- [ ] Conducted willingness-to-pay research
+- [ ] Mapped features to tiers
+
+### Pricing Structure
+- [ ] Chosen number of tiers
+- [ ] Differentiated tiers clearly
+- [ ] Set price points based on research
+- [ ] Created annual discount strategy
+- [ ] Planned enterprise/custom tier
+
+---
+
+## Task-Specific Questions
+
+1. What pricing research have you done?
+2. What's your current ARPU and conversion rate?
+3. What's your primary value metric?
+4. Who are your main pricing personas?
+5. Are you self-serve, sales-led, or hybrid?
+6. What pricing changes are you considering?
+
+---
+
+## Related Skills
+
+- **churn-prevention**: For cancel flows, save offers, and reducing revenue churn
+- **page-cro**: For optimizing pricing page conversion
+- **copywriting**: For pricing page copy
+- **marketing-psychology**: For pricing psychology principles
+- **ab-test-setup**: For testing pricing changes
+- **revops**: For deal desk processes and pipeline pricing
+- **sales-enablement**: For proposal templates and pricing presentations

package/skills/remotion/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: remotion
+description: Best practices for Remotion — programmatic video creation in React. Use when working with Remotion code, creating video compositions, adding animations, captions, audio, or rendering video.
+---
+
+# Remotion Best Practices
+
+Use this skill when dealing with Remotion code for domain-specific knowledge on video creation in React.
+
+## Key Concepts
+
+- **Compositions** — Define video dimensions, duration, FPS, and default props
+- **Sequences** — Time-based layout for layering and ordering content
+- **Interpolation** — `interpolate()` and `spring()` for smooth animations
+- **useCurrentFrame/useVideoConfig** — Core hooks for frame-based logic
+
+## Topics
+
+For detailed rules and code examples, load the relevant rule file from `rules/`:
+
+- **Animations** (`rules/animations.md`) — Fundamental animation patterns, interpolation, spring physics
+- **Text Animations** (`rules/text-animations.md`) — Typography and text animation patterns
+- **Transitions** (`rules/transitions.md`) — Scene transition patterns
+- **Timing** (`rules/timing.md`) — Interpolation curves: linear, easing, spring
+- **Sequencing** (`rules/sequencing.md`) — Sequencing patterns for multi-scene videos
+- **Compositions** (`rules/compositions.md`) — Defining compositions, stills, folders, default props
+- **Assets** (`rules/assets.md`) — Importing images, videos, audio, and fonts
+- **Videos** (`rules/videos.md`) — Embedding videos: trimming, volume, speed, looping, pitch
+- **Audio** (`rules/audio.md`) — Using audio and sound
+- **Audio Visualization** (`rules/audio-visualization.md`) — Spectrum bars, waveforms, bass-reactive effects
+- **Captions/Subtitles** (`rules/subtitles.md`) — Caption handling and styling
+- **Fonts** (`rules/fonts.md`) — Loading Google Fonts and local fonts
+- **Images** (`rules/images.md`) — Embedding images with the Img component
+- **GIFs** (`rules/gifs.md`) — Displaying GIFs synchronized with timeline
+- **Charts** (`rules/charts.md`) — Chart and data visualization patterns
+- **3D** (`rules/3d.md`) — 3D content using Three.js and React Three Fiber
+- **Lottie** (`rules/lottie.md`) — Embedding Lottie animations
+- **Light Leaks** (`rules/light-leaks.md`) — Light leak overlay effects
+- **Maps** (`rules/maps.md`) — Add maps using Mapbox and animate them
+- **Transparent Videos** (`rules/transparent-videos.md`) — Rendering with transparency
+- **Trimming** (`rules/trimming.md`) — Trimming patterns
+- **TailwindCSS** (`rules/tailwind.md`) — Using TailwindCSS in Remotion
+- **Parameters** (`rules/parameters.md`) — Make videos parametrizable with Zod schemas
+- **Calculate Metadata** (`rules/calculate-metadata.md`) — Dynamically set duration, dimensions, props
+- **Measuring Text** (`rules/measuring-text.md`) — Text dimensions, fitting, overflow checking
+- **Measuring DOM** (`rules/measuring-dom-nodes.md`) — Measuring DOM element dimensions
+- **FFmpeg** (`rules/ffmpeg.md`) — Video operations: trimming, silence detection
+- **Voiceover** (`rules/voiceover.md`) — AI-generated voiceover with ElevenLabs TTS
+- **Sound Effects** (`rules/sound-effects.md`) — Using sound effects
+- **Video Duration** (`rules/get-video-duration.md`) — Getting video duration with Mediabunny
+- **Audio Duration** (`rules/get-audio-duration.md`) — Getting audio duration with Mediabunny
+- **Video Dimensions** (`rules/get-video-dimensions.md`) — Getting video width/height with Mediabunny
+- **Can Decode** (`rules/can-decode.md`) — Check browser decode support with Mediabunny
+- **Extract Frames** (`rules/extract-frames.md`) — Extract frames at specific timestamps

package/skills/taskmaster/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: taskmaster
+description: |
+  Completion guard that prevents premature task abandonment. Use when wrapping up
+  any non-trivial task, before claiming work is "done", or when you catch yourself
+  writing a summary instead of finishing the work. Also use when the user says
+  "don't stop early", "finish everything", "make sure it's actually done", or
+  "verify completion". Adapted from github.com/blader/taskmaster.
+---
+
+# Taskmaster
+
+Completion guard. Progress is not completion. Before you stop, prove the work is done.
+
+## When to Invoke
+
+- Before claiming any non-trivial task is complete
+- When you're about to write a summary of what you did
+- When you notice yourself using phrases like "significant progress", "mostly done", or "remaining work would require..."
+- When the user explicitly asks you to finish everything
+
+## The Completion Checklist
+
+Run every item. Do not skip any. Do not summarize — execute.
+
+### 1. Goal Confrontation (Do This First)
+
+Answer these three questions explicitly in your response:
+
+a. **What is the user's stated goal or success criterion?** Write it out verbatim.
+b. **Is it achieved RIGHT NOW?** Answer "yes" or "no". Not "partially", not "mostly", not "significant progress was made". Yes or no.
+c. **If no:** you are NOT DONE. Go do more work.
+
+The ONLY exception is if the user explicitly told you to stop or deprioritized the goal. There is no other valid reason to stop.
+
+### 2. Re-read the Original Request
+
+Go back to the user's original message(s). List every discrete request or acceptance criterion. For each one, confirm it is **fully addressed** — not started, not in progress, FULLY done.
+
+If the user changed their mind or withdrew a request, treat it as resolved.
+
+### 3. Check the Task List
+
+Review every task. Any task not marked completed? Do it now — unless the user said to skip it.
+
+### 4. Check the Plan
+
+Walk through each step of the plan, INCLUDING verification steps. Any step skipped or partially done? Finish it.
+
+If the plan includes verification steps (builds, tests, lints, type-checks, smoke tests), you MUST actually run them and see them pass. Do not skip them or claim they pass without evidence.
+
+### 5. Check for Errors
+
+Did anything fail or remain unfinished? Fix it. This applies to ALL types of problems — logic errors, missing functionality, incomplete refactors, broken scripts, configuration issues, or anything else that prevents the work from being fully done.
+
+### 6. Check for Loose Ends
+
+- TODO comments you left behind?
+- Placeholder code?
+- Missing tests for new code?
+- Untested changes?
+- Follow-ups you noted but didn't act on?
+
+If any exist, resolve them now.
+
+### 7. Check for Blockers
+
+If something is blocking you, do NOT give up. Try a different approach, read more code, search for examples, re-examine your assumptions.
+
+"I didn't cause this bug" is not an excuse to stop — if it blocks your task, fix it. You own the outcome, not just your diff.
+
+## Anti-Rationalization Guide
+
+These are NOT valid reasons to stop:
+
+| Rationalization | Reality |
+|---|---|
+| "Diminishing returns" | The goal isn't met. Keep working. |
+| "Significant progress was made" | Progress is not completion. |
+| "Would require broader architectural changes" | Then make them. |
+| "No single dominant hotspot" | Keep looking. |
+| "Tried N approaches" | Try N+1. |
+| "I can't do X" | You haven't tried X yet. |
+| "This is a pre-existing issue" | If it blocks your task, it's your issue. |
+| "The remaining work is complex" | That's not a reason to stop. That's a description of your job. |
+
+## Do Not Narrate — Execute
+
+If any incomplete work remains, your ONLY job is to DO that work right now.
+
+- Do NOT respond by explaining what the remaining tasks are
+- Do NOT describe their complexity or list their dependencies
+- Do NOT ask for permission to proceed
+- Do NOT write summaries of what is left
+
+Open files, write code, run commands, fix bugs. Act.
+
+## User Instructions Override
+
+The user's latest instructions always take priority. If the user said to stop, move on, or skip something — respect that. Do not force completion of work the user no longer wants.
+
+## Attribution
+
+Core ideas adapted from [Taskmaster](https://github.com/blader/taskmaster) by blader (MIT).

package/skills/yc-office-hours/SKILL.md

@@ -0,0 +1,204 @@
+---
+name: yc-office-hours
+description: |
+  YC-style office hours. Two modes — Startup: six forcing questions that expose
+  demand reality, status quo, desperate specificity, narrowest wedge, observation,
+  and future-fit. Builder: design thinking for side projects, hackathons, and learning.
+  Use when asked to "brainstorm", "I have an idea", "help me think through this",
+  "office hours", or "is this worth building".
+---
+
+# YC Office Hours
+
+You are a **YC office hours partner**. Your job is to ensure the problem is understood before solutions are proposed. You adapt to what the user is building — startup founders get the hard questions, builders get an enthusiastic collaborator.
+
+**HARD GATE:** Do NOT write any code, scaffold any project, or take any implementation action. Your only output is a design document and concrete next steps.
+
+---
+
+## Phase 1: Context Gathering
+
+1. If in a codebase, scan `CLAUDE.md`, recent git log, and relevant files to understand context.
+2. **Ask: what's your goal with this?** Via AskUserQuestion:
+
+   > Before we dig in — what's your goal with this?
+   >
+   > - **Building a startup** (or thinking about it)
+   > - **Intrapreneurship** — internal project at a company
+   > - **Hackathon / demo** — time-boxed, need to impress
+   > - **Open source / research** — building for a community
+   > - **Learning** — leveling up, vibe coding
+   > - **Having fun** — side project, creative outlet
+
+   **Mode mapping:**
+   - Startup, intrapreneurship → **Startup mode** (Phase 2A)
+   - Everything else → **Builder mode** (Phase 2B)
+
+3. **Startup mode only — assess stage:**
+   - Pre-product (idea, no users)
+   - Has users (not yet paying)
+   - Has paying customers
+
+---
+
+## Phase 2A: Startup Mode — YC Product Diagnostic
+
+### Operating Principles
+
+**Specificity is the only currency.** "Enterprises in healthcare" is not a customer. You need a name, a role, a company, a reason.
+
+**Interest is not demand.** Waitlists, signups, "that's interesting" — none of it counts. Behavior counts. Money counts. Panic when it breaks counts.
+
+**The user's words beat the founder's pitch.** If your best customers describe your value differently than your marketing copy, rewrite the copy.
+
+**The status quo is your real competitor.** Not the other startup — the spreadsheet-and-Slack-messages workaround your user lives with.
+
+**Narrow beats wide, early.** The smallest version someone will pay for this week > the full platform vision.
+
+### Response Posture
+
+- **Be direct, not cruel.** Don't soften a hard truth into uselessness.
+- **Push once, then push again.** The first answer is usually the polished version. The real answer comes after the second push.
+- **Praise specificity when it shows up.**
+- **Name common failure patterns** — "solution in search of a problem," "hypothetical users," "assuming interest equals demand."
+- **End with the assignment.** One concrete action, not a strategy.
+
+### The Six Forcing Questions
+
+Ask **ONE AT A TIME**. Push until the answer is specific and evidence-based.
+
+**Smart routing by stage:**
+- Pre-product → Q1, Q2, Q3
+- Has users → Q2, Q4, Q5
+- Has paying customers → Q4, Q5, Q6
+
+#### Q1: Demand Reality
+"What's the strongest evidence someone actually wants this — not 'is interested,' but would be genuinely upset if it disappeared tomorrow?"
+
+Push for: specific behavior, payment, usage expansion, panic when it breaks.
+Red flags: "People say it's interesting." "We got 500 waitlist signups."
+
+#### Q2: Status Quo
+"What are your users doing right now to solve this — even badly? What does that workaround cost them?"
+
+Push for: specific workflow, hours spent, dollars wasted, tools duct-taped together.
+Red flags: "Nothing exists." If no one is doing anything, the problem probably isn't painful enough.
+
+#### Q3: Desperate Specificity
+"Name the actual human who needs this most. What's their title? What gets them fired?"
+
+Push for: a name, a role, a specific consequence.
+Red flags: "Healthcare enterprises." "SMBs." "Marketing teams." You can't email a category.
+
+#### Q4: Narrowest Wedge
+"What's the smallest possible version someone would pay real money for — this week?"
+
+Push for: one feature, one workflow, shippable in days not months.
+Red flags: "We need to build the full platform first."
+
+#### Q5: Observation & Surprise
+"Have you sat down and watched someone use this without helping them? What surprised you?"
+
+Push for: a specific surprise that contradicted assumptions.
+Red flags: "We sent out a survey." "Nothing surprising."
+Gold: users doing something the product wasn't designed for.
+
+#### Q6: Future-Fit
+"In 3 years, does your product become more essential or less?"
+
+Push for: specific claim about how their users' world changes.
+Red flags: "The market is growing 20% per year." "AI will make everything better."
+
+**Smart-skip:** If earlier answers already cover a question, skip it.
+**Escape hatch:** If user says "just do it" or provides a fully formed plan → fast-track to Phase 4.
+
+---
+
+## Phase 2B: Builder Mode — Design Partner
+
+### Operating Principles
+
+1. **Delight is the currency** — what makes someone say "whoa"?
+2. **Ship something you can show.** The best version is the one that exists.
+3. **The best side projects solve your own problem.**
+4. **Explore before you optimize.**
+
+### Response Posture
+
+- Enthusiastic, opinionated collaborator.
+- Help them find the most exciting version of their idea.
+- Suggest cool things they might not have thought of.
+- End with concrete build steps, not business validation tasks.
+
+### Questions (generative, not interrogative)
+
+Ask **ONE AT A TIME**:
+
+- **What's the coolest version of this?** What would make it genuinely delightful?
+- **Who would you show this to?** What would make them say "whoa"?
+- **What's the fastest path to something you can actually use or share?**
+- **What existing thing is closest, and how is yours different?**
+- **What's the 10x version if you had unlimited time?**
+
+**If the vibe shifts** — user starts in builder mode but mentions customers, revenue, fundraising → upgrade to Startup mode naturally.
+
+---
+
+## Phase 3: Premise Challenge
+
+Before proposing solutions:
+
+1. **Is this the right problem?** Could a different framing yield a simpler solution?
+2. **What happens if we do nothing?** Real pain or hypothetical?
+3. **What existing code/tools partially solve this?**
+
+Output premises as clear statements:
+```
+PREMISES:
+1. [statement] — agree/disagree?
+2. [statement] — agree/disagree?
+```
+
+Confirm via AskUserQuestion. If user disagrees, revise and loop back.
+
+---
+
+## Phase 4: Alternatives Generation
+
+Produce 2-3 distinct approaches. **Not optional.**
+
+For each:
+```
+APPROACH A: [Name]
+  Summary: [1-2 sentences]
+  Effort:  [S/M/L/XL]
+  Risk:    [Low/Med/High]
+  Pros:    [2-3 bullets]
+  Cons:    [2-3 bullets]
+```
+
+Rules:
+- One must be **minimal viable** (smallest diff, ships fastest)
+- One must be **ideal architecture** (best long-term)
+- One can be **creative/lateral** (unexpected approach)
+
+**RECOMMENDATION:** Choose [X] because [one-line reason].
+
+Present via AskUserQuestion. Do NOT proceed without user approval.
+
+---
+
+## Phase 5: Design Doc
+
+Write the output as a structured design document. For startup mode, include: problem statement, demand evidence, status quo, target user, narrowest wedge, premises, approaches, recommendation, open questions, success criteria, and the assignment (one concrete real-world action). For builder mode: problem statement, what makes it cool, premises, approaches, recommendation, next steps.
+
+End with a "What I noticed" section — observational reflections referencing specific things the user said. Quote their words back. 2-4 bullets.
+
+---
+
+## Important Rules
+
+- **Never start implementation.** Design docs, not code.
+- **Questions ONE AT A TIME.** Never batch multiple questions.
+- **The assignment is mandatory.** Every session ends with a concrete action.
+- **If user provides a formed plan:** skip Phase 2 but still run Phase 3 (Premise Challenge) and Phase 4 (Alternatives).

package/src/commands/init.ts

@@ -7,6 +7,7 @@ import { resetConfig } from "../utils/config";
 import { runMigrations } from "../db/migrate";
 import { closeDb } from "../db/connection";
 import { startDaemon, isRunning } from "../core/daemon";
+import { registerService, isServiceInstalled } from "./service";
 import { errMsg } from "../utils/errors";
 import { enrichSlackConfig } from "../cli/channels";
 import yaml from "js-yaml";
@@ -434,12 +435,25 @@ export async function runInit(): Promise<void> {
 
     resetConfig();
 
+    // Install system service (launchd/systemd) for auto-restart on crash
+    if (!isServiceInstalled()) {
+      try {
+        await registerService();
+        console.log(`\n  \u2713 installed system service (auto-restart on crash)`);
+      } catch (err) {
+        console.log(`\n  \u26a0 could not install system service: ${errMsg(err)}`);
+        console.log(`    run 'nia service install' manually for auto-restart`);
+      }
+    } else {
+      console.log(`\n  - system service already installed`);
+    }
+
     // Auto-start daemon
     if (!isRunning()) {
       const pid = startDaemon();
-      console.log(`\n  \u2713 nia started (pid: ${pid})`);
+      console.log(`  \u2713 nia started (pid: ${pid})`);
     } else {
-      console.log(`\n  - nia already running`);
+      console.log(`  - nia already running`);
     }
 
     console.log("\nDone.");

package/src/commands/service.ts

@@ -8,7 +8,15 @@ const PLIST_NAME = "com.niahere.agent";
 const SYSTEMD_UNIT = "niahere.service";
 
 function getExecCommand(): [string, string] {
-  return [process.execPath, process.argv[1]];
+  const execPath = process.execPath;
+  // process.argv[1] may be undefined when called outside the normal CLI flow
+  // (e.g. from bun -e or programmatic import). Fall back to the known entry point.
+  let cliPath = process.argv[1];
+  if (!cliPath || cliPath === "undefined") {
+    const { resolve } = require("path");
+    cliPath = resolve(import.meta.dir, "../cli/index.ts");
+  }
+  return [execPath, cliPath];
 }
 
 // --- macOS launchd ---

package/src/core/daemon.ts

@@ -162,6 +162,20 @@ export async function runDaemon(): Promise<void> {
     }
   }
 
+  // Crash handlers — ensure PID cleanup and logging on unhandled errors.
+  // Without these, an unhandled rejection kills the process silently,
+  // leaving a stale PID file that blocks restarts and hides the cause.
+  process.on("uncaughtException", (err) => {
+    log.fatal({ err }, "uncaught exception — cleaning up");
+    removePid();
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    log.fatal({ reason }, "unhandled rejection — cleaning up");
+    removePid();
+    process.exit(1);
+  });
+
   writePid(process.pid);
   log.info({ pid: process.pid }, "daemon started");