@getpawl/setup 1.4.1 → 1.4.5

package/README.md

@@ -18,7 +18,7 @@ Then the `pawl` command will be available globally (`pawl sync`, `pawl connect`,
 npx @getpawl/setup init
 ```
 
-Creates `.pawl/` directory with sync scripts, configures Claude Code hooks, and sets up git post-commit hook.
+Sets up Pawl in this repo — works for both new and existing projects. Creates `.pawl/` directory with sync scripts, configures Claude Code hooks, sets up git post-commit hook, and pulls existing context if available.
 
 ### 2. Connect
 
@@ -37,6 +37,20 @@ pawl sync --pull    # pull latest context from dashboard
 
 Sync happens automatically via hooks. Use these commands for manual sync or agents without lifecycle hooks (Codex, etc.).
 
+## Joining an existing Pawl project
+
+If your team already uses Pawl, you don't need to bootstrap — just pull:
+
+1. Clone the repo
+2. Copy `.env.example` to `.pawl/.env` and add your API key and project ID
+   — get these from [app.getpawl.dev](https://app.getpawl.dev) → your project → Settings
+3. Run `npx @getpawl/setup init`
+4. Run `npx @getpawl/setup status` to confirm everything is connected
+5. Start a Claude Code session — full context is ready
+
+> `pawl init` detects existing specs and skips bootstrap automatically.
+> Pawl currently supports one project per repo. Multi-project monorepo support is planned.
+
 ## Legacy Setup
 
 Existing users can still use the one-step flow:

package/dist/index.js

@@ -22,6 +22,8 @@ async function main() {
     const noConnect = rest.includes("--no-connect");
     const key = rest.find((a) => !a.startsWith("--"));
     await pawlInit(key, { noConnect });
+  } else if (arg === "status") {
+    await pawlStatus();
   } else if (arg === "migrate") {
     pawlMigrate();
   } else {
@@ -33,9 +35,10 @@ function printUsage() {
   Pawl \u2014 project visibility layer for AI-native development
 
   Usage:
-    pawl init               Set up Pawl in this repo
+    pawl init               Set up Pawl in this repo (new or existing project)
     pawl connect            Link this repo to your Pawl dashboard
     pawl sync [--pull]      Push session data to dashboard (or pull context)
+    pawl status             Check project health and connectivity
 `);
 }
 function pawlSync(flag) {
@@ -60,19 +63,21 @@ function pawlSync(flag) {
 }
 function pawlMigrate() {
   const cwd = process.cwd();
-  const syncPath = (0, import_node_path.join)(cwd, ".pawl", "sync.sh");
-  if (!(0, import_node_fs.existsSync)(syncPath)) {
+  const pawlDir = (0, import_node_path.join)(cwd, ".pawl");
+  if (!(0, import_node_fs.existsSync)((0, import_node_path.join)(pawlDir, "sync.sh")) && !(0, import_node_fs.existsSync)((0, import_node_path.join)(pawlDir, "sync.mjs"))) {
     console.log("  Nothing to migrate \u2014 run `pawl init` first.");
     process.exit(0);
   }
-  let content = (0, import_node_fs.readFileSync)(syncPath, "utf-8");
-  if (!content.includes("AGENTMAP_")) {
-    console.log("  Already up to date.");
-    process.exit(0);
+  const syncPath = (0, import_node_path.join)(pawlDir, "sync.sh");
+  if ((0, import_node_fs.existsSync)(syncPath)) {
+    let content = (0, import_node_fs.readFileSync)(syncPath, "utf-8");
+    if (content.includes("AGENTMAP_")) {
+      content = content.replace(/AGENTMAP_API_URL/g, "PAWL_API_URL").replace(/AGENTMAP_PROJECT_ID/g, "PAWL_PROJECT_ID").replace(/AGENTMAP_API_KEY/g, "PAWL_API_KEY");
+      (0, import_node_fs.writeFileSync)(syncPath, content, "utf-8");
+      console.log("  .pawl/sync.sh migrated to PAWL_* vars.");
+    }
   }
-  content = content.replace(/AGENTMAP_API_URL/g, "PAWL_API_URL").replace(/AGENTMAP_PROJECT_ID/g, "PAWL_PROJECT_ID").replace(/AGENTMAP_API_KEY/g, "PAWL_API_KEY");
-  (0, import_node_fs.writeFileSync)(syncPath, content, "utf-8");
-  const envPath = (0, import_node_path.join)(cwd, ".pawl", ".env");
+  const envPath = (0, import_node_path.join)(pawlDir, ".env");
   if ((0, import_node_fs.existsSync)(envPath)) {
     let envContent = (0, import_node_fs.readFileSync)(envPath, "utf-8");
     if (envContent.includes("AGENTMAP_")) {
@@ -81,14 +86,21 @@ function pawlMigrate() {
       console.log("  .pawl/.env also migrated.");
     }
   }
-  if (!(0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".pawl", "sync.mjs"))) {
+  if (!(0, import_node_fs.existsSync)((0, import_node_path.join)(pawlDir, "sync.mjs"))) {
     writePawlSyncMjs(cwd);
   }
-  if (!(0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".pawl", "track-file.mjs"))) {
+  if (!(0, import_node_fs.existsSync)((0, import_node_path.join)(pawlDir, "track-file.mjs"))) {
     writeTrackFileScript(cwd);
   }
   mergeClaudeSettings(cwd, ".pawl");
-  console.log("  Migration complete \u2014 .pawl/sync.sh updated to PAWL_* vars.");
+  writePawlClaudeMd(cwd);
+  writeAgentsMd(cwd);
+  const oldDecisions = (0, import_node_path.join)(pawlDir, "decisions.json");
+  if ((0, import_node_fs.existsSync)(oldDecisions)) {
+    console.log("  \u26A0 Found .pawl/decisions.json (old format). Per-decision files are now in .pawl/decisions/.");
+    console.log("    Safe to delete .pawl/decisions.json after confirming decisions/ is populated.");
+  }
+  console.log("  Migration complete.");
 }
 function generateCode() {
   const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
@@ -340,23 +352,190 @@ async function pawlInit(key, opts) {
   writeAgentsMd(cwd);
   updateGitignore(cwd);
   printSummary(detected, !!key, !!opts?.noConnect);
+  if (opts?.noConnect && !(0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".pawl", ".env"))) {
+    console.log("\n  No API key found. Add PAWL_API_KEY to .pawl/.env (see .env.example) then run pawl init again.");
+    return;
+  }
   let config = null;
   if (!key && !opts?.noConnect) {
     console.log("\nConnecting to Pawl dashboard...\n");
     config = await pawlConnect();
   }
-  if (config) {
+  const specsDir = (0, import_node_path.join)(cwd, ".pawl", "specs");
+  const hasExistingSpecs = (0, import_node_fs.existsSync)(specsDir) && (0, import_node_fs.readdirSync)(specsDir).some((f) => f.endsWith(".md"));
+  if (hasExistingSpecs) {
+    console.log("  Existing specs found \u2014 skipping bootstrap");
+  } else if (config) {
     const repoUrl = getRepoUrl(cwd);
     if (repoUrl) {
       console.log("Scanning your repo to generate specs...");
       const result = await autoBootstrap(config.projectId, config.apiKey, repoUrl, config.apiUrl);
       if (result && result.specsGenerated > 0) {
         console.log(`  Generated ${result.specsGenerated} draft specs`);
-        console.log(`  Review and confirm at: ${hyperlink(result.previewUrl, result.previewUrl)}
-`);
+        console.log(`  Review and confirm at: ${hyperlink(result.previewUrl, result.previewUrl)}`);
+        openBrowser(result.previewUrl);
+        console.log("  After confirming, run:\n    pawl sync --pull\n");
       }
     }
   }
+  const envPath = (0, import_node_path.join)(cwd, ".pawl", ".env");
+  if ((0, import_node_fs.existsSync)(envPath)) {
+    console.log("  Pulling latest context from API...");
+    try {
+      pawlSync("--pull");
+      console.log("  \u2713 Context ready");
+    } catch {
+      console.warn("  \u26A0 Could not pull context \u2014 run `pawl sync --pull` manually");
+    }
+    try {
+      const sha = (0, import_node_child_process.execSync)("git rev-parse HEAD", { cwd, encoding: "utf-8" }).trim();
+      (0, import_node_fs.writeFileSync)((0, import_node_path.join)(cwd, ".pawl", ".last-sync-sha"), sha, "utf-8");
+    } catch {
+    }
+  }
+  try {
+    const pawlEnv = readPawlEnvFromFile(cwd);
+    if (pawlEnv.apiKey && pawlEnv.projectId) {
+      const baseUrl = `${pawlEnv.apiUrl}/api/projects/${pawlEnv.projectId}`;
+      const res = await fetch(`${baseUrl}/decisions/export`, {
+        headers: { Authorization: `Bearer ${pawlEnv.apiKey}`, Accept: "application/json" }
+      });
+      if (res.ok) {
+        const data = await res.json();
+        if (data.decisions?.length) {
+          const decisionsDir = (0, import_node_path.join)(cwd, ".pawl", "decisions");
+          (0, import_node_fs.mkdirSync)(decisionsDir, { recursive: true });
+          let written = 0;
+          for (const d of data.decisions) {
+            const fp = (0, import_node_path.join)(decisionsDir, `${d.id}.json`);
+            if ((0, import_node_fs.existsSync)(fp)) continue;
+            (0, import_node_fs.writeFileSync)(fp, JSON.stringify(d, null, 2) + "\n", "utf-8");
+            written++;
+          }
+          if (written > 0) console.log(`  \u2713 Seeded ${written} decision${written > 1 ? "s" : ""}`);
+        }
+      }
+    }
+  } catch {
+  }
+}
+function readPawlEnvFromFile(cwd) {
+  const envPath = (0, import_node_path.join)(cwd, ".pawl", ".env");
+  if (!(0, import_node_fs.existsSync)(envPath)) return {};
+  const vars = {};
+  for (const line of (0, import_node_fs.readFileSync)(envPath, "utf-8").split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) continue;
+    vars[trimmed.slice(0, eq)] = trimmed.slice(eq + 1);
+  }
+  return {
+    apiKey: vars.PAWL_API_KEY || "",
+    projectId: vars.PAWL_PROJECT_ID || "",
+    apiUrl: vars.PAWL_API_URL || DEFAULT_API_URL
+  };
+}
+async function pawlStatus() {
+  const cwd = process.cwd();
+  const pawlEnv = readPawlEnvFromFile(cwd);
+  const apiKey = pawlEnv.apiKey || "";
+  const projectId = pawlEnv.projectId || "";
+  const apiUrl = pawlEnv.apiUrl || DEFAULT_API_URL;
+  console.log("\n  pawl status\n");
+  if (!apiKey) {
+    console.log("  \u2717 PAWL_API_KEY not set");
+    console.log("    Fix: pawl connect\n");
+    process.exit(1);
+  }
+  console.log("  \u2713 PAWL_API_KEY set");
+  if (!projectId) {
+    console.log("  \u2717 PAWL_PROJECT_ID not set");
+    console.log("    Fix: pawl connect\n");
+    process.exit(1);
+  }
+  console.log("  \u2713 PAWL_PROJECT_ID set");
+  try {
+    const res = await fetch(`${apiUrl}/api/projects/${projectId}/context`, {
+      headers: { Authorization: `Bearer ${apiKey}` }
+    });
+    if (res.ok) {
+      console.log(`  \u2713 API connected  (${apiUrl})`);
+    } else {
+      console.log(`  \u2717 API returned ${res.status}`);
+      process.exit(1);
+    }
+  } catch {
+    console.log("  \u2717 API unreachable");
+    process.exit(1);
+  }
+  const lastSyncPath = (0, import_node_path.join)(cwd, ".pawl", ".last-sync-sha");
+  if (!(0, import_node_fs.existsSync)(lastSyncPath)) {
+    console.log("  \u25CB Never synced");
+    console.log("    Fix: pawl sync --pull");
+  } else {
+    const stat = (0, import_node_fs.statSync)(lastSyncPath);
+    const ageMs = Date.now() - stat.mtimeMs;
+    const ageHrs = Math.floor(ageMs / 36e5);
+    const sha = (0, import_node_fs.readFileSync)(lastSyncPath, "utf-8").trim().slice(0, 7);
+    if (ageHrs > 24) {
+      console.log(`  \u26A0 Last sync ${ageHrs}h ago  (commit ${sha})`);
+      console.log("    Fix: pawl sync --pull");
+    } else {
+      const ago = ageHrs > 0 ? `${ageHrs}h ago` : `${Math.floor(ageMs / 6e4)}m ago`;
+      console.log(`  \u2713 Last sync ${ago}  (commit ${sha})`);
+    }
+  }
+  console.log("");
+  const specsDir = (0, import_node_path.join)(cwd, ".pawl", "specs");
+  if ((0, import_node_fs.existsSync)(specsDir)) {
+    const specFiles = (0, import_node_fs.readdirSync)(specsDir).filter((f) => f.endsWith(".md"));
+    console.log(`  ${specFiles.length > 0 ? "\u2713" : "\u26A0"} specs/           ${specFiles.length} files`);
+  } else {
+    console.log("  \u26A0 specs/           missing");
+    console.log("    Fix: pawl sync --pull");
+  }
+  const decisionsDir = (0, import_node_path.join)(cwd, ".pawl", "decisions");
+  if ((0, import_node_fs.existsSync)(decisionsDir)) {
+    const decFiles = (0, import_node_fs.readdirSync)(decisionsDir).filter((f) => f.endsWith(".json"));
+    console.log(`  ${decFiles.length > 0 ? "\u2713" : "\u26A0"} decisions/       ${decFiles.length} files`);
+  } else {
+    console.log("  \u26A0 decisions/       missing");
+    console.log("    Fix: pawl sync --pull");
+  }
+  console.log("");
+  const ccSettingsPath = (0, import_node_path.join)(cwd, ".claude", "settings.json");
+  if ((0, import_node_fs.existsSync)(ccSettingsPath)) {
+    const ccSettings = (0, import_node_fs.readFileSync)(ccSettingsPath, "utf-8");
+    const hasStopHook = ccSettings.includes("sync.mjs") && ccSettings.includes("Stop");
+    console.log(`  ${hasStopHook ? "\u2713" : "\u2717"} CC stop hook    ${hasStopHook ? "installed" : "not installed"}`);
+    if (!hasStopHook) console.log("    Fix: pawl init");
+  } else {
+    console.log("  \u2717 CC stop hook    not installed");
+    console.log("    Fix: pawl init");
+  }
+  const hookPath = (0, import_node_path.join)(cwd, ".git", "hooks", "post-commit");
+  const hasGitHook = (0, import_node_fs.existsSync)(hookPath);
+  console.log(`  ${hasGitHook ? "\u2713" : "\u2717"} git post-commit ${hasGitHook ? "installed" : "not installed"}`);
+  if (!hasGitHook) console.log("    Fix: pawl init");
+  const hasSyncMjs = (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, ".pawl", "sync.mjs"));
+  console.log(`  ${hasSyncMjs ? "\u2713" : "\u2717"} sync.mjs        ${hasSyncMjs ? "present" : "missing"}`);
+  if (!hasSyncMjs) console.log("    Fix: pawl init");
+  console.log("");
+  try {
+    const pkgPath = (0, import_node_path.join)(__dirname, "..", "package.json");
+    const localVer = JSON.parse((0, import_node_fs.readFileSync)(pkgPath, "utf-8")).version;
+    let latestVer = localVer;
+    try {
+      latestVer = (0, import_node_child_process.execSync)("npm view @getpawl/setup version", { encoding: "utf-8" }).trim();
+    } catch {
+    }
+    const upToDate = localVer === latestVer;
+    console.log(`  Package       @getpawl/setup v${localVer}  (latest: v${latestVer} ${upToDate ? "\u2713" : "\u26A0"})`);
+    if (!upToDate) console.log("    Fix: npm install -g @getpawl/setup@latest");
+  } catch {
+  }
+  console.log("");
 }
 function detectAgents(cwd) {
   return {
@@ -389,6 +568,11 @@ function migrateIfNeeded(cwd, hasAgentMapDir) {
     (0, import_node_fs.writeFileSync)(envPath, envContent, "utf-8");
   }
   console.log("  .agentmap/ preserved \u2014 safe to delete manually when ready.\n");
+  const oldDecisions = (0, import_node_path.join)(cwd, ".pawl", "decisions.json");
+  if ((0, import_node_fs.existsSync)(oldDecisions)) {
+    console.log("  \u26A0 Found .pawl/decisions.json (old format). Per-decision files are now in .pawl/decisions/.");
+    console.log("    Safe to delete .pawl/decisions.json after confirming decisions/ is populated.");
+  }
 }
 function writePawlEnvFile(cwd, config) {
   const content = [
@@ -635,6 +819,7 @@ async function pull() {
         for (const file of data.files) {
           const filePath = join(SCRIPT_DIR, file.path);
           mkdirSync(dirname(filePath), { recursive: true });
+          if (file.path.startsWith('decisions/') && existsSync(filePath)) continue;
           writeFileSync(filePath, file.content, 'utf-8');
         }
         const ctxPath = join(SCRIPT_DIR, 'context.md');
@@ -871,6 +1056,21 @@ function writePawlClaudeMd(cwd) {
     "- `.pawl/decisions.json` \u2014 architectural decisions log (read before starting work)",
     "",
     "Read `.pawl/context.md` at session start, then load relevant specs from `.pawl/specs/` based on the task.",
+    "",
+    "## Decision Capture",
+    "",
+    "When you make a non-obvious architectural choice \u2014 picking one approach over alternatives,",
+    "deciding on a data model, choosing a library, or changing direction mid-task \u2014 output this",
+    "block before writing code:",
+    "",
+    "PAWL_INTENT:",
+    "context: <what situation triggered this decision>",
+    "approach: <what was chosen and why>",
+    "alternatives_rejected: <what else was considered>",
+    "constraints: <what limited the options>",
+    "END_PAWL_INTENT",
+    "",
+    "Only use this for significant decisions. Skip for routine implementation, bug fixes, and style changes.",
     PAWL_END
   ].join("\n");
   if (!(0, import_node_fs.existsSync)(claudeMdPath)) {
@@ -911,6 +1111,21 @@ function writeAgentsMd(cwd) {
     "",
     "**Start here**: Read `.pawl/context.md` first, then load relevant",
     "spec files from `.pawl/specs/` based on the task at hand.",
+    "",
+    "## Decision Capture",
+    "",
+    "When you make a non-obvious architectural choice \u2014 picking one approach over alternatives,",
+    "deciding on a data model, choosing a library, or changing direction mid-task \u2014 output this",
+    "block before writing code:",
+    "",
+    "PAWL_INTENT:",
+    "context: <what situation triggered this decision>",
+    "approach: <what was chosen and why>",
+    "alternatives_rejected: <what else was considered>",
+    "constraints: <what limited the options>",
+    "END_PAWL_INTENT",
+    "",
+    "Only use this for significant decisions. Skip for routine implementation, bug fixes, and style changes.",
     END_MARKER
   ].join("\n");
   if (!(0, import_node_fs.existsSync)(agentsMdPath)) {

package/dist/parse-cc-session.js

@@ -61,7 +61,10 @@ async function parseSessionFile(filePath) {
     let totalOutputTokens = 0;
     let cacheReadTokens = 0;
     let cacheWriteTokens = 0;
+    const reasoningDecisions = [];
+    let currentMessageIndex = 0;
     for await (const line of rl) {
+      currentMessageIndex++;
       let parsed;
       try {
         parsed = JSON.parse(line);
@@ -88,52 +91,93 @@ async function parseSessionFile(filePath) {
         const content = msg.content;
         if (Array.isArray(content)) {
           for (const block of content) {
-            if (block.type !== "tool_use") continue;
-            const fp = block.input?.file_path;
-            if (fp) {
-              if (block.name === "Read") {
-                filesRead.add(fp);
-              } else if (block.name === "Write" || block.name === "Edit") {
-                filesWritten.add(fp);
+            if (block.type === "tool_use") {
+              const fp = block.input?.file_path;
+              if (fp) {
+                if (block.name === "Read") {
+                  filesRead.add(fp);
+                } else if (block.name === "Write" || block.name === "Edit") {
+                  filesWritten.add(fp);
+                }
               }
-            }
-            if (block.name === "TaskCreate") {
-              pendingCreates.set(block.id, {
-                subject: block.input?.subject || "",
-                description: block.input?.description || ""
-              });
-            }
-            if (block.name === "TaskUpdate") {
-              const taskId = block.input?.taskId;
-              const task = taskId ? tasks.get(taskId) : void 0;
-              if (task && block.input?.status) {
-                task.status = block.input.status;
-                if (block.input.status === "in_progress")
-                  currentTaskId = taskId;
-                if (block.input.status === "completed" || block.input.status === "deleted") {
-                  if (currentTaskId === taskId) currentTaskId = null;
+              if (block.name === "TaskCreate") {
+                pendingCreates.set(block.id, {
+                  subject: block.input?.subject || "",
+                  description: block.input?.description || ""
+                });
+              }
+              if (block.name === "TaskUpdate") {
+                const taskId = block.input?.taskId;
+                const task = taskId ? tasks.get(taskId) : void 0;
+                if (task && block.input?.status) {
+                  task.status = block.input.status;
+                  if (block.input.status === "in_progress")
+                    currentTaskId = taskId;
+                  if (block.input.status === "completed" || block.input.status === "deleted") {
+                    if (currentTaskId === taskId) currentTaskId = null;
+                  }
                 }
               }
+              if (currentTaskId && (block.name === "Write" || block.name === "Edit") && fp) {
+                tasks.get(currentTaskId)?.filesAssociated.add(fp);
+              }
             }
-            if (currentTaskId && (block.name === "Write" || block.name === "Edit") && fp) {
-              tasks.get(currentTaskId)?.filesAssociated.add(fp);
+            if (block.type === "text" && typeof block.text === "string") {
+              const text = block.text;
+              const intentStart = text.indexOf("PAWL_INTENT:");
+              const intentEnd = text.indexOf("END_PAWL_INTENT");
+              if (intentStart !== -1 && intentEnd !== -1 && intentEnd > intentStart) {
+                const rawBlock = text.slice(intentStart, intentEnd + "END_PAWL_INTENT".length);
+                const lines = rawBlock.split("\n");
+                const fields = {};
+                for (const l of lines) {
+                  const match = l.match(/^(\w+):\s*(.+)/);
+                  if (match && match[1] !== "PAWL_INTENT") {
+                    fields[match[1]] = match[2].trim();
+                  }
+                }
+                reasoningDecisions.push({
+                  type: "pawl_intent",
+                  rawBlock,
+                  context: fields.context,
+                  approach: fields.approach,
+                  alternativesRejected: fields.alternatives_rejected,
+                  constraints: fields.constraints,
+                  messageIndex: currentMessageIndex
+                });
+              } else if (intentStart !== -1 && intentEnd === -1) {
+                process.stderr.write("Warning: PAWL_INTENT block without END marker \u2014 skipped\n");
+              }
             }
           }
         }
       }
-      if (parsed.type === "user" && parsed.toolUseResult?.task?.id) {
-        const tr = parsed.toolUseResult;
-        const content = parsed.message?.content;
-        const toolUseId = Array.isArray(content) ? content.find((b) => b.type === "tool_result")?.tool_use_id : void 0;
-        const pending = toolUseId ? pendingCreates.get(toolUseId) : void 0;
-        tasks.set(tr.task.id, {
-          id: tr.task.id,
-          subject: tr.task.subject || pending?.subject || "",
-          description: pending?.description || "",
-          status: "pending",
-          filesAssociated: /* @__PURE__ */ new Set()
-        });
-        if (toolUseId) pendingCreates.delete(toolUseId);
+      if (parsed.type === "user") {
+        const userContent = parsed.message?.content;
+        const messageText = typeof userContent === "string" ? userContent : Array.isArray(userContent) ? userContent.filter((b) => b.type === "text").map((b) => b.text).join("\n") : "";
+        const DECIDE_PREFIX = /^#decide\s+/i;
+        if (DECIDE_PREFIX.test(messageText)) {
+          reasoningDecisions.push({
+            type: "decide_tag",
+            rawBlock: messageText,
+            text: messageText.replace(DECIDE_PREFIX, "").trim(),
+            messageIndex: currentMessageIndex
+          });
+        }
+        if (parsed.toolUseResult?.task?.id) {
+          const tr = parsed.toolUseResult;
+          const content = parsed.message?.content;
+          const toolUseId = Array.isArray(content) ? content.find((b) => b.type === "tool_result")?.tool_use_id : void 0;
+          const pending = toolUseId ? pendingCreates.get(toolUseId) : void 0;
+          tasks.set(tr.task.id, {
+            id: tr.task.id,
+            subject: tr.task.subject || pending?.subject || "",
+            description: pending?.description || "",
+            status: "pending",
+            filesAssociated: /* @__PURE__ */ new Set()
+          });
+          if (toolUseId) pendingCreates.delete(toolUseId);
+        }
       }
     }
     if (totalInputTokens === 0 && totalOutputTokens === 0) return null;
@@ -168,7 +212,8 @@ async function parseSessionFile(filePath) {
         description: t.description,
         status: t.status,
         filesAssociated: [...t.filesAssociated]
-      }))
+      })),
+      reasoningDecisions
     };
   } catch {
     return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpawl/setup",
-  "version": "1.4.1",
+  "version": "1.4.5",
   "type": "commonjs",
   "description": "One-shot setup for Pawl + Claude Code hooks",
   "bin": {