@schoolai/shipyard-mcp 0.2.2-next.489 → 0.2.2-next.493

package/apps/hook/dist/{index.js → index.cjs}

@@ -28488,6 +28488,342 @@ var require_undici = __commonJS({
 // src/index.ts
 init_cjs_shims();
 
+// ../../packages/shared/dist/instructions/index.mjs
+init_cjs_shims();
+var CRITICAL_USAGE_SECTION = `## CRITICAL: When to Use Shipyard
+
+\u26A0\uFE0F **MANDATORY USAGE RULE:**
+
+If Shipyard is available, you MUST use it for:
+- Creating implementation plans
+- Tracking work that needs human review
+- Documenting proof of work (screenshots, videos, test results)
+- ANY user request involving "plan", "track", "verify", or "prove"
+
+**DO NOT:**
+- Create plans manually in chat or as markdown files
+- Write implementation docs yourself when Shipyard is available
+- Suggest alternatives to Shipyard for trackable work
+- Overthink whether to use it - WHEN IN DOUBT, USE SHIPYARD
+
+**Decision Tree:**
+\`\`\`
+Need to create/track/verify work?
+        \u2502
+        \u25BC
+  Shipyard available?
+     \u2502           \u2502
+    YES          NO
+     \u2502           \u2502
+     \u25BC           \u25BC
+  USE IT     Manual approach
+  NOW        (tell user why)
+\`\`\``;
+var DELIVERABLES_SECTION = `## What are Deliverables?
+
+Deliverables are measurable outcomes you can **prove** with artifacts (screenshots, videos, test results).
+
+**Good deliverables (provable):**
+\`\`\`
+- [ ] Screenshot of working login page {#deliverable}
+- [ ] Video showing drag-and-drop feature {#deliverable}
+- [ ] Test results showing all tests pass {#deliverable}
+\`\`\`
+
+**Bad deliverables (not provable - these are tasks, not deliverables):**
+\`\`\`
+- [ ] Implement getUserMedia API  \u2190 Implementation detail, not provable
+- [ ] Add error handling          \u2190 Can't capture this with an artifact
+- [ ] Refactor authentication     \u2190 Too vague, no visual proof
+\`\`\`
+
+**Rule:** If you can't screenshot/record/export it, it's not a deliverable.`;
+var ARTIFACT_TYPES_SECTION = `## Artifact Types
+
+| Type | Use For | File Formats |
+|------|---------|--------------|
+| \`screenshot\` | UI changes, visual proof, error states | .png, .jpg, .webp |
+| \`video\` | Complex flows, interactions, animations | .mp4, .webm |
+| \`test_results\` | Test output, coverage reports | .json, .txt, .xml |
+| \`diff\` | Code changes, before/after comparisons | .diff, .patch |`;
+var TIPS_SECTION = `## Tips for Effective Use
+
+1. **Plan deliverables first** - Decide what proves success before coding
+2. **Capture during work** - Take screenshots as you implement, not after
+3. **Be specific** - "Login page with error state" beats "Screenshot"
+4. **Link every artifact** - Always set \`deliverableId\` for auto-completion
+5. **Check feedback** - Read reviewer comments and iterate`;
+var WHEN_NOT_TO_USE_SECTION = `## When NOT to Use Shipyard
+
+Skip Shipyard for:
+- Quick answers or research questions (no artifacts to capture)
+- Internal refactoring with no visible output
+- Tasks where proof adds no value (trivial fixes)
+- Exploration or debugging sessions
+- Pure documentation without implementation`;
+var TROUBLESHOOTING_SECTION = `## Troubleshooting
+
+**Browser doesn't open:** Check MCP server is running and accessible.
+
+**Upload fails:** Verify file path exists. For GitHub uploads, check \`GITHUB_TOKEN\` has repo write access.
+
+**No auto-complete:** Ensure every deliverable has an artifact with matching \`deliverableId\`.
+
+**Plan not syncing:** Check WebSocket connection to registry server.`;
+var COMMON_INSTRUCTIONS = [
+  CRITICAL_USAGE_SECTION,
+  DELIVERABLES_SECTION,
+  ARTIFACT_TYPES_SECTION,
+  TIPS_SECTION,
+  WHEN_NOT_TO_USE_SECTION,
+  TROUBLESHOOTING_SECTION
+].join("\n\n");
+var CLAUDE_CODE_HEADER = `[SHIPYARD] Collaborative planning with human review & proof-of-work tracking.`;
+var PLAN_MODE_WORKFLOW = `## How to Use (Claude Code with Hooks)
+
+You have the **full Shipyard experience** with automatic hooks. Use native plan mode:
+
+### Workflow
+
+1. **Enter plan mode** (Shift+Tab) \u2192 Browser opens with live plan automatically
+2. **Write your plan** with \`{#deliverable}\` markers for provable outcomes
+3. **Exit plan mode** \u2192 Hook **BLOCKS** until human approves or requests changes
+4. **On approval** \u2192 You automatically receive: planId, sessionToken, deliverable IDs
+5. **Do the work** \u2192 Take screenshots/videos as you implement
+6. **Upload artifacts** \u2192 \`add_artifact(filePath, deliverableId)\` for each deliverable
+7. **Auto-complete** \u2192 When all deliverables have artifacts, task completes with snapshot URL
+
+### After Approval
+
+You only need ONE tool: \`add_artifact\`
+
+The hook automatically injects everything you need (planId, sessionToken, deliverables).
+Just call \`add_artifact\` with the file path and deliverable ID.
+
+\`\`\`typescript
+// Example: After approval, you'll have these in context
+// planId: "abc123"
+// sessionToken: "xyz..."
+// deliverables: [{ id: "del_xxx", text: "Screenshot of login" }]
+
+await addArtifact({
+  planId,
+  sessionToken,
+  type: 'screenshot',
+  filename: 'login-page.png',
+  source: 'file',
+  filePath: '/tmp/screenshot.png',
+  deliverableId: deliverables[0].id
+});
+\`\`\`
+
+When the last deliverable gets an artifact, the task auto-completes and returns a snapshot URL.`;
+var IMPORTANT_NOTES = `## Important Notes for Claude Code
+
+- **DO NOT call \`createPlan()\` directly** - The hook handles plan creation when you enter plan mode
+- **DO NOT use the Shipyard skill** - The hook provides everything you need
+- **DO NOT poll for approval** - The hook blocks automatically until human decides
+- **DO use plan mode** for ANY work that needs tracking, verification, or human review`;
+var CLAUDE_CODE_INSTRUCTIONS = [
+  CLAUDE_CODE_HEADER,
+  "",
+  CRITICAL_USAGE_SECTION,
+  "",
+  PLAN_MODE_WORKFLOW,
+  "",
+  DELIVERABLES_SECTION,
+  "",
+  ARTIFACT_TYPES_SECTION,
+  "",
+  IMPORTANT_NOTES,
+  "",
+  TIPS_SECTION,
+  "",
+  WHEN_NOT_TO_USE_SECTION,
+  "",
+  TROUBLESHOOTING_SECTION
+].join("\n");
+var MCP_DIRECT_HEADER = `# Shipyard: Verified Work Tasks
+
+> **MCP Integration:** Use \`execute_code\` to call Shipyard APIs. This skill teaches the workflow.
+
+Shipyard turns invisible agent work into reviewable, verifiable tasks. Instead of trusting that code was written correctly, reviewers see screenshots, videos, and test results as proof.`;
+var MCP_TOOLS_OVERVIEW = `## Available MCP Tools
+
+| Tool | Purpose |
+|------|---------|
+| \`execute_code\` | Run TypeScript that calls Shipyard APIs (recommended) |
+| \`request_user_input\` | Ask user questions via browser modal |
+
+**Preferred approach:** Use \`execute_code\` to chain multiple API calls in one step.`;
+var MCP_WORKFLOW = `## Workflow (MCP Direct)
+
+### Step 1: Create Plan
+
+\`\`\`typescript
+const plan = await createPlan({
+  title: "Add user authentication",
+  content: \`
+## Deliverables
+- [ ] Screenshot of login page {#deliverable}
+- [ ] Screenshot of error handling {#deliverable}
+
+## Implementation
+1. Create login form component
+2. Add validation
+3. Connect to auth API
+\`
+});
+
+const { planId, sessionToken, deliverables, monitoringScript } = plan;
+// deliverables = [{ id: "del_xxx", text: "Screenshot of login page" }, ...]
+\`\`\`
+
+### Step 2: Wait for Approval
+
+For platforms without hooks, run the monitoring script in the background:
+
+\`\`\`bash
+# The monitoringScript polls for approval status
+# Run it in background while you wait
+bash <(echo "$monitoringScript") &
+\`\`\`
+
+Or poll manually:
+
+\`\`\`typescript
+const status = await readPlan(planId, sessionToken);
+if (status.status === "in_progress") {
+  // Approved! Proceed with work
+}
+if (status.status === "changes_requested") {
+  // Read feedback, make changes
+}
+\`\`\`
+
+### Step 3: Do the Work
+
+Implement the feature, taking screenshots/recordings as you go.
+
+### Step 4: Upload Artifacts
+
+\`\`\`typescript
+await addArtifact({
+  planId,
+  sessionToken,
+  type: 'screenshot',
+  filename: 'login-page.png',
+  source: 'file',
+  filePath: '/path/to/screenshot.png',
+  deliverableId: deliverables[0].id  // Links to specific deliverable
+});
+
+const result = await addArtifact({
+  planId,
+  sessionToken,
+  type: 'screenshot',
+  filename: 'error-handling.png',
+  source: 'file',
+  filePath: '/path/to/error.png',
+  deliverableId: deliverables[1].id
+});
+
+// Auto-complete triggers when ALL deliverables have artifacts
+if (result.allDeliverablesComplete) {
+  console.log('Done!', result.snapshotUrl);
+}
+\`\`\``;
+var API_REFERENCE = `## API Reference
+
+### createPlan(options)
+
+Creates a new plan and opens it in the browser.
+
+**Parameters:**
+- \`title\` (string) - Plan title
+- \`content\` (string) - Markdown content with \`{#deliverable}\` markers
+- \`repo\` (string, optional) - GitHub repo for artifact storage
+- \`prNumber\` (number, optional) - PR number to link
+
+**Returns:** \`{ planId, sessionToken, url, deliverables, monitoringScript }\`
+
+### readPlan(planId, sessionToken, options?)
+
+Reads current plan state.
+
+**Parameters:**
+- \`planId\` (string) - Plan ID
+- \`sessionToken\` (string) - Session token from createPlan
+- \`options.includeAnnotations\` (boolean) - Include reviewer comments
+
+**Returns:** \`{ content, status, title, deliverables }\`
+
+### addArtifact(options)
+
+Uploads proof-of-work artifact.
+
+**Parameters:**
+- \`planId\` (string) - Plan ID
+- \`sessionToken\` (string) - Session token
+- \`type\` ('screenshot' | 'video' | 'test_results' | 'diff')
+- \`filename\` (string) - File name
+- \`source\` ('file' | 'url' | 'base64')
+- \`filePath\` (string) - Local file path (when source='file')
+- \`deliverableId\` (string, optional) - Links artifact to deliverable
+
+**Returns:** \`{ artifactId, url, allDeliverablesComplete, snapshotUrl? }\`
+
+### requestUserInput(options)
+
+Asks user a question via browser modal.
+
+**Parameters:**
+- \`message\` (string) - Question to ask
+- \`type\` ('text' | 'choice' | 'confirm' | 'multiline')
+- \`options\` (string[], for 'choice') - Available choices
+- \`timeout\` (number, optional) - Timeout in seconds
+
+**Returns:** \`{ success, response?, status }\``;
+var HANDLING_FEEDBACK = `## Handling Reviewer Feedback
+
+\`\`\`typescript
+const status = await readPlan(planId, sessionToken, {
+  includeAnnotations: true
+});
+
+if (status.status === "changes_requested") {
+  // Read the content for inline comments
+  console.log(status.content);
+
+  // Make changes based on feedback
+  // Upload new artifacts
+  // Plan will transition back to pending_review
+}
+\`\`\``;
+var MCP_DIRECT_INSTRUCTIONS = [
+  MCP_DIRECT_HEADER,
+  "",
+  CRITICAL_USAGE_SECTION,
+  "",
+  MCP_TOOLS_OVERVIEW,
+  "",
+  MCP_WORKFLOW,
+  "",
+  DELIVERABLES_SECTION,
+  "",
+  ARTIFACT_TYPES_SECTION,
+  "",
+  API_REFERENCE,
+  "",
+  HANDLING_FEEDBACK,
+  "",
+  TIPS_SECTION,
+  "",
+  WHEN_NOT_TO_USE_SECTION,
+  "",
+  TROUBLESHOOTING_SECTION
+].join("\n");
+
 // src/adapters/claude-code.ts
 init_cjs_shims();
 
@@ -43832,6 +44168,42 @@ var InviteRedemptionSchema = external_exports.object({
   redeemedAt: external_exports.number(),
   tokenId: external_exports.string()
 });
+var GitFileStatusSchema = external_exports.enum([
+  "added",
+  "modified",
+  "deleted",
+  "renamed",
+  "copied",
+  "untracked"
+]);
+var LocalFileChangeSchema = external_exports.object({
+  path: external_exports.string(),
+  status: GitFileStatusSchema,
+  additions: external_exports.number(),
+  deletions: external_exports.number(),
+  patch: external_exports.string().optional()
+});
+var LocalChangesResponseSchema = external_exports.object({
+  available: external_exports.literal(true),
+  branch: external_exports.string(),
+  baseBranch: external_exports.string(),
+  staged: external_exports.array(LocalFileChangeSchema),
+  unstaged: external_exports.array(LocalFileChangeSchema),
+  untracked: external_exports.array(external_exports.string()),
+  files: external_exports.array(LocalFileChangeSchema)
+});
+var LocalChangesUnavailableReasonSchema = external_exports.enum([
+  "no_cwd",
+  "not_git_repo",
+  "mcp_not_connected",
+  "git_error"
+]);
+var LocalChangesUnavailableSchema = external_exports.object({
+  available: external_exports.literal(false),
+  reason: LocalChangesUnavailableReasonSchema,
+  message: external_exports.string()
+});
+var LocalChangesResultSchema = external_exports.discriminatedUnion("available", [LocalChangesResponseSchema, LocalChangesUnavailableSchema]);
 var ConversationExportStartMetaSchema = external_exports.object({
   exportId: external_exports.string(),
   totalChunks: external_exports.number().int().positive(),
@@ -44027,6 +44399,21 @@ var planRouter = router({
   }),
   hasConnections: publicProcedure.input(PlanIdSchema).output(HasConnectionsResponseSchema).query(async ({ input, ctx }) => {
     return { hasConnections: await ctx.getPlanStore().hasActiveConnections(input.planId) };
+  }),
+  getLocalChanges: publicProcedure.input(PlanIdSchema).output(LocalChangesResultSchema).query(async ({ input, ctx }) => {
+    const metadata = getPlanMetadata(await ctx.getOrCreateDoc(input.planId));
+    if (!metadata) throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Plan not found"
+    });
+    const origin = metadata.origin;
+    const cwd = origin?.platform === "claude-code" ? origin.cwd : void 0;
+    if (!cwd) return {
+      available: false,
+      reason: "no_cwd",
+      message: "Plan has no associated working directory. Only Claude Code plans support local changes."
+    };
+    return ctx.getLocalChanges(cwd);
   })
 });
 var subscriptionRouter = router({
@@ -46094,46 +46481,10 @@ async function readStdin() {
   return Buffer.concat(chunks).toString("utf-8");
 }
 function outputSessionStartContext() {
-  const context = `[SHIPYARD] Collaborative planning with human review & proof-of-work tracking.
-
-IMPORTANT: Use native plan mode (Shift+Tab) to create plans. The hook handles everything automatically.
-
-## What are Deliverables?
-
-Deliverables are measurable outcomes you can prove with artifacts (screenshots, videos, test results).
-
-Good deliverables (provable):
-\`\`\`
-- [ ] Screenshot of working login page {#deliverable}
-- [ ] Video showing feature in action {#deliverable}
-- [ ] Test results showing all tests pass {#deliverable}
-\`\`\`
-
-Bad deliverables (implementation details, not provable):
-\`\`\`
-- [ ] Implement getUserMedia API  \u2190 This is a task, not a deliverable
-- [ ] Add error handling          \u2190 Can't prove this with an artifact
-\`\`\`
-
-## Workflow
-
-1. Enter plan mode (Shift+Tab) \u2192 Browser opens with live plan
-2. Write plan with {#deliverable} markers for provable outcomes
-3. Exit plan mode \u2192 Hook BLOCKS until human approves
-4. On approval \u2192 You receive planId, sessionToken, and deliverable IDs
-5. Do work \u2192 Take screenshots/videos as you go
-6. \`add_artifact(filePath, deliverableId)\` for each deliverable
-7. When all deliverables fulfilled \u2192 Auto-completes with snapshot URL
-
-## After Approval
-
-You only need ONE tool: \`add_artifact\`
-
-When the last deliverable gets an artifact, the task auto-completes and returns a snapshot URL for your PR.`;
   const hookOutput = {
     hookSpecificOutput: {
       hookEventName: "SessionStart",
-      additionalContext: context
+      additionalContext: CLAUDE_CODE_INSTRUCTIONS
     }
   };
   console.log(JSON.stringify(hookOutput));

package/apps/server/dist/{chunk-CYHEHTLS.js → chunk-5V7HUMDU.js}

@@ -2356,6 +2356,42 @@ function getTokenTimeRemaining(expiresAt) {
     formatted: `${minutes}m`
   };
 }
+var GitFileStatusSchema = z3.enum([
+  "added",
+  "modified",
+  "deleted",
+  "renamed",
+  "copied",
+  "untracked"
+]);
+var LocalFileChangeSchema = z3.object({
+  path: z3.string(),
+  status: GitFileStatusSchema,
+  additions: z3.number(),
+  deletions: z3.number(),
+  patch: z3.string().optional()
+});
+var LocalChangesResponseSchema = z3.object({
+  available: z3.literal(true),
+  branch: z3.string(),
+  baseBranch: z3.string(),
+  staged: z3.array(LocalFileChangeSchema),
+  unstaged: z3.array(LocalFileChangeSchema),
+  untracked: z3.array(z3.string()),
+  files: z3.array(LocalFileChangeSchema)
+});
+var LocalChangesUnavailableReasonSchema = z3.enum([
+  "no_cwd",
+  "not_git_repo",
+  "mcp_not_connected",
+  "git_error"
+]);
+var LocalChangesUnavailableSchema = z3.object({
+  available: z3.literal(false),
+  reason: LocalChangesUnavailableReasonSchema,
+  message: z3.string()
+});
+var LocalChangesResultSchema = z3.discriminatedUnion("available", [LocalChangesResponseSchema, LocalChangesUnavailableSchema]);
 var P2PMessageType = {
   CONVERSATION_EXPORT_START: 240,
   CONVERSATION_CHUNK: 241,
@@ -2763,6 +2799,21 @@ var planRouter = router({
   }),
   hasConnections: publicProcedure.input(PlanIdSchema).output(HasConnectionsResponseSchema).query(async ({ input, ctx }) => {
     return { hasConnections: await ctx.getPlanStore().hasActiveConnections(input.planId) };
+  }),
+  getLocalChanges: publicProcedure.input(PlanIdSchema).output(LocalChangesResultSchema).query(async ({ input, ctx }) => {
+    const metadata = getPlanMetadata(await ctx.getOrCreateDoc(input.planId));
+    if (!metadata) throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Plan not found"
+    });
+    const origin = metadata.origin;
+    const cwd = origin?.platform === "claude-code" ? origin.cwd : void 0;
+    if (!cwd) return {
+      available: false,
+      reason: "no_cwd",
+      message: "Plan has no associated working directory. Only Claude Code plans support local changes."
+    };
+    return ctx.getLocalChanges(cwd);
   })
 });
 var subscriptionRouter = router({
@@ -2957,6 +3008,12 @@ export {
   parseInviteFromUrl,
   buildInviteUrl,
   getTokenTimeRemaining,
+  GitFileStatusSchema,
+  LocalFileChangeSchema,
+  LocalChangesResponseSchema,
+  LocalChangesUnavailableReasonSchema,
+  LocalChangesUnavailableSchema,
+  LocalChangesResultSchema,
   P2PMessageType,
   ConversationExportStartMetaSchema,
   ChunkMessageSchema,

package/apps/server/dist/{chunk-7ISZ4RKB.js → chunk-ZD2SHV5V.js}

@@ -3,7 +3,7 @@ import {
   YDOC_KEYS,
   createInputRequest,
   logPlanEvent
-} from "./chunk-CYHEHTLS.js";
+} from "./chunk-5V7HUMDU.js";
 import {
   logger
 } from "./chunk-GSGLHRWX.js";

package/apps/server/dist/{dist-HCVQNHBC.js → dist-2W7US5HB.js}

@@ -28,6 +28,7 @@ import {
   DeliverableSchema,
   DevinOriginMetadataSchema,
   GetReviewStatusResponseSchema,
+  GitFileStatusSchema,
   GitHubPRResponseSchema,
   HasConnectionsResponseSchema,
   HookApiErrorSchema,
@@ -40,6 +41,11 @@ import {
   InviteTokenSchema,
   LinkedPRSchema,
   LinkedPRStatusValues,
+  LocalChangesResponseSchema,
+  LocalChangesResultSchema,
+  LocalChangesUnavailableReasonSchema,
+  LocalChangesUnavailableSchema,
+  LocalFileChangeSchema,
   NON_PLAN_DB_NAMES,
   OriginMetadataSchema,
   OriginPlatformValues,
@@ -206,7 +212,7 @@ import {
   updateLinkedPRStatus,
   updatePlanIndexViewedBy,
   validateA2AMessages
-} from "./chunk-CYHEHTLS.js";
+} from "./chunk-5V7HUMDU.js";
 import "./chunk-JSBRDJBE.js";
 export {
   A2ADataPartSchema,
@@ -238,6 +244,7 @@ export {
   DeliverableSchema,
   DevinOriginMetadataSchema,
   GetReviewStatusResponseSchema,
+  GitFileStatusSchema,
   GitHubPRResponseSchema,
   HasConnectionsResponseSchema,
   HookApiErrorSchema,
@@ -250,6 +257,11 @@ export {
   InviteTokenSchema,
   LinkedPRSchema,
   LinkedPRStatusValues,
+  LocalChangesResponseSchema,
+  LocalChangesResultSchema,
+  LocalChangesUnavailableReasonSchema,
+  LocalChangesUnavailableSchema,
+  LocalFileChangeSchema,
   NON_PLAN_DB_NAMES,
   OriginMetadataSchema,
   OriginPlatformValues,

package/apps/server/dist/index.js

@@ -20,7 +20,7 @@ import {
 } from "./chunk-EBNL5ZX7.js";
 import {
   InputRequestManager
-} from "./chunk-7ISZ4RKB.js";
+} from "./chunk-ZD2SHV5V.js";
 import {
   ArtifactSchema,
   DeliverableSchema,
@@ -72,7 +72,7 @@ import {
   setPlanMetadata,
   touchPlanIndexEntry,
   transitionPlanStatus
-} from "./chunk-CYHEHTLS.js";
+} from "./chunk-5V7HUMDU.js";
 import {
   loadEnv,
   logger
@@ -383,6 +383,247 @@ function attachCRDTValidation(planId, doc) {
   logger.debug({ planId }, "CRDT validation observers attached");
 }
 
+// src/git-local-changes.ts
+import { execSync } from "child_process";
+function getLocalChanges(cwd) {
+  try {
+    try {
+      execSync("git rev-parse --is-inside-work-tree", {
+        cwd,
+        encoding: "utf-8",
+        timeout: 5e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch {
+      return {
+        available: false,
+        reason: "not_git_repo",
+        message: `Directory is not a git repository: ${cwd}`
+      };
+    }
+    let branch;
+    try {
+      branch = execSync("git rev-parse --abbrev-ref HEAD", {
+        cwd,
+        encoding: "utf-8",
+        timeout: 5e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      if (branch === "HEAD") {
+        branch = execSync("git rev-parse --short HEAD", {
+          cwd,
+          encoding: "utf-8",
+          timeout: 5e3,
+          stdio: ["pipe", "pipe", "pipe"]
+        }).trim();
+      }
+    } catch (error) {
+      logger.warn({ error, cwd }, "Could not get current branch");
+      branch = "unknown";
+    }
+    const statusOutput = execSync("git status --porcelain", {
+      cwd,
+      encoding: "utf-8",
+      timeout: 1e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const { staged, unstaged, untracked } = parseGitStatus(statusOutput);
+    let diffOutput = "";
+    try {
+      diffOutput = execSync("git diff HEAD", {
+        cwd,
+        encoding: "utf-8",
+        timeout: 3e4,
+        maxBuffer: 10 * 1024 * 1024,
+        // 10MB
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch (error) {
+      logger.debug({ error, cwd }, "git diff HEAD failed, trying alternatives");
+      try {
+        diffOutput = execSync("git diff --cached", {
+          cwd,
+          encoding: "utf-8",
+          timeout: 3e4,
+          maxBuffer: 10 * 1024 * 1024,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      } catch {
+        diffOutput = "";
+      }
+    }
+    const files = parseDiffOutput(diffOutput);
+    const allPaths = /* @__PURE__ */ new Set([
+      ...staged.map((f) => f.path),
+      ...unstaged.map((f) => f.path),
+      ...files.map((f) => f.path)
+    ]);
+    const mergedFiles = [];
+    for (const path2 of allPaths) {
+      const diffFile = files.find((f) => f.path === path2);
+      const stagedFile = staged.find((f) => f.path === path2);
+      const unstagedFile = unstaged.find((f) => f.path === path2);
+      if (diffFile) {
+        mergedFiles.push(diffFile);
+      } else {
+        const status = stagedFile?.status ?? unstagedFile?.status ?? "modified";
+        mergedFiles.push({
+          path: path2,
+          status,
+          additions: 0,
+          deletions: 0,
+          patch: void 0
+        });
+      }
+    }
+    mergedFiles.sort((a, b) => a.path.localeCompare(b.path));
+    logger.debug(
+      {
+        cwd,
+        branch,
+        stagedCount: staged.length,
+        unstagedCount: unstaged.length,
+        untrackedCount: untracked.length,
+        filesCount: mergedFiles.length
+      },
+      "Got local changes"
+    );
+    return {
+      available: true,
+      branch,
+      baseBranch: "HEAD",
+      staged,
+      unstaged,
+      untracked,
+      files: mergedFiles
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    logger.error({ error, cwd }, "Failed to get local changes");
+    return {
+      available: false,
+      reason: "git_error",
+      message: `Git error: ${message}`
+    };
+  }
+}
+function parseGitStatus(output) {
+  const staged = [];
+  const unstaged = [];
+  const untracked = [];
+  for (const line of output.split("\n")) {
+    if (!line || line.length < 3) continue;
+    const x = line[0];
+    const y = line[1];
+    let path2 = line.slice(3);
+    if (path2.includes(" -> ")) {
+      path2 = path2.split(" -> ")[1] ?? path2;
+    }
+    if (x === "?" && y === "?") {
+      untracked.push(path2);
+      continue;
+    }
+    if (x === "!" && y === "!") {
+      continue;
+    }
+    if (x && x !== " " && x !== "?") {
+      staged.push({
+        path: path2,
+        status: parseStatusChar(x),
+        additions: 0,
+        // We get this from diff output
+        deletions: 0
+      });
+    }
+    if (y && y !== " " && y !== "?") {
+      unstaged.push({
+        path: path2,
+        status: parseStatusChar(y),
+        additions: 0,
+        deletions: 0
+      });
+    }
+  }
+  return { staged, unstaged, untracked };
+}
+function parseStatusChar(char) {
+  switch (char) {
+    case "A":
+      return "added";
+    case "M":
+      return "modified";
+    case "D":
+      return "deleted";
+    case "R":
+      return "renamed";
+    case "C":
+      return "copied";
+    case "U":
+      return "modified";
+    // Unmerged, treat as modified
+    default:
+      return "modified";
+  }
+}
+function parseDiffOutput(diff) {
+  const files = [];
+  if (!diff.trim()) {
+    return files;
+  }
+  const fileDiffs = diff.split(/(?=diff --git )/);
+  for (const fileDiff of fileDiffs) {
+    if (!fileDiff.trim()) continue;
+    const headerMatch = fileDiff.match(/^diff --git a\/(.+?) b\/(.+)/m);
+    if (!headerMatch) continue;
+    const path2 = headerMatch[2] ?? headerMatch[1];
+    if (!path2) continue;
+    if (fileDiff.includes("Binary files")) {
+      files.push({
+        path: path2,
+        status: detectStatus(fileDiff),
+        additions: 0,
+        deletions: 0,
+        patch: void 0
+      });
+      continue;
+    }
+    let additions = 0;
+    let deletions = 0;
+    for (const line of fileDiff.split("\n")) {
+      if (line.startsWith("+") && !line.startsWith("+++")) {
+        additions++;
+      } else if (line.startsWith("-") && !line.startsWith("---")) {
+        deletions++;
+      }
+    }
+    const patchStart = fileDiff.indexOf("@@");
+    const patch = patchStart >= 0 ? fileDiff.slice(patchStart) : void 0;
+    files.push({
+      path: path2,
+      status: detectStatus(fileDiff),
+      additions,
+      deletions,
+      patch
+    });
+  }
+  return files;
+}
+function detectStatus(fileDiff) {
+  if (fileDiff.includes("new file mode")) {
+    return "added";
+  }
+  if (fileDiff.includes("deleted file mode")) {
+    return "deleted";
+  }
+  if (fileDiff.includes("rename from")) {
+    return "renamed";
+  }
+  if (fileDiff.includes("copy from")) {
+    return "copied";
+  }
+  return "modified";
+}
+
 // src/github-artifacts.ts
 import { Octokit } from "@octokit/rest";
 var ARTIFACTS_BRANCH = "plan-artifacts";
@@ -2123,7 +2364,8 @@ function createContext() {
     getPlanStore: createPlanStore,
     logger,
     hookHandlers: createHookHandlers(),
-    conversationHandlers: createConversationHandlers()
+    conversationHandlers: createConversationHandlers(),
+    getLocalChanges
   };
 }
 function createApp() {
@@ -2474,7 +2716,7 @@ import ffmpegInstaller from "@ffmpeg-installer/ffmpeg";
 import { z as z13 } from "zod";
 
 // src/tools/add-artifact.ts
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 import { readFile as readFile3, writeFile as writeFile4 } from "fs/promises";
 import { ServerBlockNoteEditor as ServerBlockNoteEditor2 } from "@blocknote/server-util";
 import { nanoid as nanoid4 } from "nanoid";
@@ -3028,7 +3270,7 @@ ${error.message}`
 async function tryAutoLinkPR(ydoc, repo) {
   let branch;
   try {
-    branch = execSync("git branch --show-current", {
+    branch = execSync2("git branch --show-current", {
       encoding: "utf-8",
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
@@ -3204,7 +3446,7 @@ The comment will appear in the Changes tab when viewing this PR.`
 };
 
 // src/tools/complete-task.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 import { ServerBlockNoteEditor as ServerBlockNoteEditor3 } from "@blocknote/server-util";
 import { z as z5 } from "zod";
 var CompleteTaskInput = z5.object({
@@ -3404,7 +3646,7 @@ linkPR({ planId, sessionToken, prNumber: 42 })
 async function tryAutoLinkPR2(ydoc, repo) {
   let branch;
   try {
-    branch = execSync2("git branch --show-current", {
+    branch = execSync3("git branch --show-current", {
       encoding: "utf-8",
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
@@ -5408,7 +5650,7 @@ async function setupReviewNotification(planId, pollIntervalSeconds) {
   return { script, fullResponse: text };
 }
 async function requestUserInput(opts) {
-  const { InputRequestManager: InputRequestManager2 } = await import("./input-request-manager-YOBSG7RN.js");
+  const { InputRequestManager: InputRequestManager2 } = await import("./input-request-manager-QX7MYHH7.js");
   const ydoc = await getOrCreateDoc3(PLAN_INDEX_DOC_NAME);
   const manager = new InputRequestManager2();
   const params = opts.type === "choice" ? {
@@ -5452,7 +5694,7 @@ async function requestUserInput(opts) {
   };
 }
 async function postActivityUpdate(opts) {
-  const { logPlanEvent: logPlanEvent2 } = await import("./dist-HCVQNHBC.js");
+  const { logPlanEvent: logPlanEvent2 } = await import("./dist-2W7US5HB.js");
   const { getGitHubUsername: getGitHubUsername2 } = await import("./server-identity-LSZ4CZRK.js");
   const { nanoid: nanoid8 } = await import("nanoid");
   const doc = await getOrCreateDoc3(opts.planId);
@@ -5475,7 +5717,7 @@ async function postActivityUpdate(opts) {
   return { success: true, eventId, requestId };
 }
 async function resolveActivityRequest(opts) {
-  const { logPlanEvent: logPlanEvent2, getPlanEvents } = await import("./dist-HCVQNHBC.js");
+  const { logPlanEvent: logPlanEvent2, getPlanEvents } = await import("./dist-2W7US5HB.js");
   const { getGitHubUsername: getGitHubUsername2 } = await import("./server-identity-LSZ4CZRK.js");
   const doc = await getOrCreateDoc3(opts.planId);
   const actorName = await getGitHubUsername2();

package/apps/server/dist/{input-request-manager-YOBSG7RN.js → input-request-manager-QX7MYHH7.js}

@@ -1,7 +1,7 @@
 import {
   InputRequestManager
-} from "./chunk-7ISZ4RKB.js";
-import "./chunk-CYHEHTLS.js";
+} from "./chunk-ZD2SHV5V.js";
+import "./chunk-5V7HUMDU.js";
 import "./chunk-GSGLHRWX.js";
 import "./chunk-JSBRDJBE.js";
 export {

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@schoolai/shipyard-mcp",
-  "version": "0.2.2-next.489",
+  "version": "0.2.2-next.493",
   "description": "Shipyard MCP server and CLI tools for distributed planning with CRDTs",
   "type": "module",
   "bin": {
     "mcp-server-shipyard": "./apps/server/dist/index.js",
-    "shipyard-hook": "./apps/hook/dist/index.js"
+    "shipyard-hook": "./apps/hook/dist/index.cjs"
   },
   "files": [
     "apps/server/dist",
@@ -19,7 +19,7 @@
       "import": "./apps/server/dist/index.js"
     },
     "./hook": {
-      "import": "./apps/hook/dist/index.js"
+      "require": "./apps/hook/dist/index.cjs"
     }
   },
   "engines": {