feat: Octarine notes integration + auto-save for all integrations

Add Octarine as a third notes app integration alongside Obsidian and Bear.
Uses the octarine:// URI scheme to create notes via deep links, following
the same x-callback-url pattern as Bear.

- New file: packages/ui/utils/octarine.ts (cookie-backed settings)
- Server: saveToOctarine() in integrations.ts, wired into /api/approve
  and /api/save-notes endpoints
- UI: Octarine tab in Settings, card in Export > Notes, dropdown button,
  Cmd+S shortcut support
- Parallelize all integration saves with Promise.allSettled (was sequential)
- Add auto-save on plan arrival toggle to Bear and Octarine (Obsidian
  already had this), consolidate into a single effect + single API call

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: backnotprop

packages/editor/App.tsx

@@ -20,6 +20,7 @@ import { CompletionOverlay } from '@plannotator/ui/components/CompletionOverlay'
 import { UpdateBanner } from '@plannotator/ui/components/UpdateBanner';
 import { getObsidianSettings, getEffectiveVaultPath, isObsidianConfigured, CUSTOM_PATH_SENTINEL } from '@plannotator/ui/utils/obsidian';
 import { getBearSettings } from '@plannotator/ui/utils/bear';
+import { getOctarineSettings, isOctarineConfigured } from '@plannotator/ui/utils/octarine';
 import { getDefaultNotesApp } from '@plannotator/ui/utils/defaultNotesApp';
 import { getAgentSwitchSettings, getEffectiveAgentName } from '@plannotator/ui/utils/agentSwitch';
 import { getPlanSaveSettings } from '@plannotator/ui/utils/planSave';
@@ -366,29 +367,52 @@ const App: React.FC = () => {
     setBlocks(parseMarkdownToBlocks(markdown));
   }, [markdown]);
 
-  // Auto-save to Obsidian on plan arrival (if enabled)
+  // Auto-save to notes apps on plan arrival (each gated by its autoSave toggle)
   const autoSaveAttempted = useRef(false);
   useEffect(() => {
     if (!isApiMode || !markdown || isSharedSession || annotateMode) return;
     if (autoSaveAttempted.current) return;
 
-    const obsSettings = getObsidianSettings();
-    if (!obsSettings.autoSave || !obsSettings.enabled) return;
+    const body: { obsidian?: object; bear?: object; octarine?: object } = {};
+    const targets: string[] = [];
 
-    const vaultPath = getEffectiveVaultPath(obsSettings);
-    if (!vaultPath) return;
+    const obsSettings = getObsidianSettings();
+    if (obsSettings.autoSave && obsSettings.enabled) {
+      const vaultPath = getEffectiveVaultPath(obsSettings);
+      if (vaultPath) {
+        body.obsidian = {
+          vaultPath,
+          folder: obsSettings.folder || 'plannotator',
+          plan: markdown,
+          ...(obsSettings.filenameFormat && { filenameFormat: obsSettings.filenameFormat }),
+          ...(obsSettings.filenameSeparator && obsSettings.filenameSeparator !== 'space' && { filenameSeparator: obsSettings.filenameSeparator }),
+        };
+        targets.push('Obsidian');
+      }
+    }
 
-    autoSaveAttempted.current = true;
+    const bearSettings = getBearSettings();
+    if (bearSettings.autoSave && bearSettings.enabled) {
+      body.bear = {
+        plan: markdown,
+        customTags: bearSettings.customTags,
+        tagPosition: bearSettings.tagPosition,
+      };
+      targets.push('Bear');
+    }
 
-    const body = {
-      obsidian: {
-        vaultPath,
-        folder: obsSettings.folder || 'plannotator',
+    const octSettings = getOctarineSettings();
+    if (octSettings.autoSave && octSettings.enabled && octSettings.workspace) {
+      body.octarine = {
         plan: markdown,
-        ...(obsSettings.filenameFormat && { filenameFormat: obsSettings.filenameFormat }),
-        ...(obsSettings.filenameSeparator && obsSettings.filenameSeparator !== 'space' && { filenameSeparator: obsSettings.filenameSeparator }),
-      },
-    };
+        workspace: octSettings.workspace,
+        folder: octSettings.folder || 'plannotator',
+      };
+      targets.push('Octarine');
+    }
+
+    if (targets.length === 0) return;
+    autoSaveAttempted.current = true;
 
     fetch('/api/save-notes', {
       method: 'POST',
@@ -397,14 +421,15 @@ const App: React.FC = () => {
     })
       .then(res => res.json())
       .then(data => {
-        if (data.results?.obsidian?.success) {
-          setNoteSaveToast({ type: 'success', message: 'Auto-saved to Obsidian' });
+        const failed = targets.filter(t => !data.results?.[t.toLowerCase()]?.success);
+        if (failed.length === 0) {
+          setNoteSaveToast({ type: 'success', message: `Auto-saved to ${targets.join(' & ')}` });
         } else {
-          setNoteSaveToast({ type: 'error', message: 'Auto-save to Obsidian failed' });
+          setNoteSaveToast({ type: 'error', message: `Auto-save failed for ${failed.join(' & ')}` });
         }
       })
       .catch(() => {
-        setNoteSaveToast({ type: 'error', message: 'Auto-save to Obsidian failed' });
+        setNoteSaveToast({ type: 'error', message: 'Auto-save failed' });
       })
       .finally(() => setTimeout(() => setNoteSaveToast(null), 3000));
   }, [isApiMode, markdown, isSharedSession, annotateMode]);
@@ -471,11 +496,12 @@ const App: React.FC = () => {
     try {
       const obsidianSettings = getObsidianSettings();
       const bearSettings = getBearSettings();
+      const octarineSettings = getOctarineSettings();
       const agentSwitchSettings = getAgentSwitchSettings();
       const planSaveSettings = getPlanSaveSettings();
 
       // Build request body - include integrations if enabled
-      const body: { obsidian?: object; bear?: object; feedback?: string; agentSwitch?: string; planSave?: { enabled: boolean; customPath?: string }; permissionMode?: string } = {};
+      const body: { obsidian?: object; bear?: object; octarine?: object; feedback?: string; agentSwitch?: string; planSave?: { enabled: boolean; customPath?: string }; permissionMode?: string } = {};
 
       // Include permission mode for Claude Code
       if (origin === 'claude-code') {
@@ -513,6 +539,14 @@ const App: React.FC = () => {
         };
       }
 
+      if (octarineSettings.enabled && octarineSettings.workspace) {
+        body.octarine = {
+          plan: markdown,
+          workspace: octarineSettings.workspace,
+          folder: octarineSettings.folder || 'plannotator',
+        };
+      }
+
       // Include annotations as feedback if any exist (for OpenCode "approve with notes")
       const hasDocAnnotations = Array.from(linkedDocHook.getDocAnnotations().values()).some(
         (d) => d.annotations.length > 0 || d.globalAttachments.length > 0
@@ -717,9 +751,9 @@ const App: React.FC = () => {
     setTimeout(() => setNoteSaveToast(null), 3000);
   };
 
-  const handleQuickSaveToNotes = async (target: 'obsidian' | 'bear') => {
+  const handleQuickSaveToNotes = async (target: 'obsidian' | 'bear' | 'octarine') => {
     setShowExportDropdown(false);
-    const body: { obsidian?: object; bear?: object } = {};
+    const body: { obsidian?: object; bear?: object; octarine?: object } = {};
 
     if (target === 'obsidian') {
       const s = getObsidianSettings();
@@ -742,7 +776,16 @@ const App: React.FC = () => {
         tagPosition: bs.tagPosition,
       };
     }
+    if (target === 'octarine') {
+      const os = getOctarineSettings();
+      body.octarine = {
+        plan: markdown,
+        workspace: os.workspace,
+        folder: os.folder || 'plannotator',
+      };
+    }
 
+    const targetName = target === 'obsidian' ? 'Obsidian' : target === 'bear' ? 'Bear' : 'Octarine';
     try {
       const res = await fetch('/api/save-notes', {
         method: 'POST',
@@ -752,7 +795,7 @@ const App: React.FC = () => {
       const data = await res.json();
       const result = data.results?.[target];
       if (result?.success) {
-        setNoteSaveToast({ type: 'success', message: `Saved to ${target === 'obsidian' ? 'Obsidian' : 'Bear'}` });
+        setNoteSaveToast({ type: 'success', message: `Saved to ${targetName}` });
       } else {
         setNoteSaveToast({ type: 'error', message: result?.error || 'Save failed' });
       }
@@ -780,13 +823,16 @@ const App: React.FC = () => {
       const defaultApp = getDefaultNotesApp();
       const obsOk = isObsidianConfigured();
       const bearOk = getBearSettings().enabled;
+      const octOk = isOctarineConfigured();
 
       if (defaultApp === 'download') {
         handleDownloadAnnotations();
       } else if (defaultApp === 'obsidian' && obsOk) {
         handleQuickSaveToNotes('obsidian');
       } else if (defaultApp === 'bear' && bearOk) {
         handleQuickSaveToNotes('bear');
+      } else if (defaultApp === 'octarine' && octOk) {
+        handleQuickSaveToNotes('octarine');
       } else {
         setInitialExportTab('notes');
         setShowExport(true);
@@ -1025,7 +1071,18 @@ const App: React.FC = () => {
                         Save to Bear
                       </button>
                     )}
-                    {isApiMode && !isObsidianConfigured() && !getBearSettings().enabled && (
+                    {isApiMode && isOctarineConfigured() && (
+                      <button
+                        onClick={() => handleQuickSaveToNotes('octarine')}
+                        className="w-full text-left px-3 py-1.5 text-xs hover:bg-muted transition-colors flex items-center gap-2"
+                      >
+                        <svg className="w-3.5 h-3.5 text-muted-foreground" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={2}>
+                          <path strokeLinecap="round" strokeLinejoin="round" d="M5 5a2 2 0 012-2h10a2 2 0 012 2v16l-7-3.5L5 21V5z" />
+                        </svg>
+                        Save to Octarine
+                      </button>
+                    )}
+                    {isApiMode && !isObsidianConfigured() && !getBearSettings().enabled && !isOctarineConfigured() && (
                       <div className="px-3 py-2 text-[10px] text-muted-foreground">
                         No notes apps configured.
                       </div>

packages/server/index.ts

@@ -15,8 +15,10 @@ import { openEditorDiff } from "./ide";
 import {
   saveToObsidian,
   saveToBear,
+  saveToOctarine,
   type ObsidianConfig,
   type BearConfig,
+  type OctarineConfig,
   type IntegrationResult,
 } from "./integrations";
 import {
@@ -274,29 +276,33 @@ export async function startPlannotatorServer(
 
           // API: Save to notes (decoupled from approve/deny)
           if (url.pathname === "/api/save-notes" && req.method === "POST") {
-            const results: { obsidian?: IntegrationResult; bear?: IntegrationResult } = {};
+            const results: { obsidian?: IntegrationResult; bear?: IntegrationResult; octarine?: IntegrationResult } = {};
 
             try {
               const body = (await req.json()) as {
                 obsidian?: ObsidianConfig;
                 bear?: BearConfig;
+                octarine?: OctarineConfig;
               };
 
+              // Run integrations in parallel — they're independent
+              const promises: Promise<void>[] = [];
               if (body.obsidian?.vaultPath && body.obsidian?.plan) {
-                results.obsidian = await saveToObsidian(body.obsidian);
-                if (results.obsidian.success) {
-                  console.error(`[Obsidian] Saved plan to: ${results.obsidian.path}`);
-                } else {
-                  console.error(`[Obsidian] Save failed: ${results.obsidian.error}`);
-                }
+                promises.push(saveToObsidian(body.obsidian).then(r => { results.obsidian = r; }));
               }
-
               if (body.bear?.plan) {
-                results.bear = await saveToBear(body.bear);
-                if (results.bear.success) {
-                  console.error(`[Bear] Saved plan to Bear`);
-                } else {
-                  console.error(`[Bear] Save failed: ${results.bear.error}`);
+                promises.push(saveToBear(body.bear).then(r => { results.bear = r; }));
+              }
+              if (body.octarine?.plan && body.octarine?.workspace) {
+                promises.push(saveToOctarine(body.octarine).then(r => { results.octarine = r; }));
+              }
+              await Promise.allSettled(promises);
+
+              for (const [name, result] of Object.entries(results)) {
+                if (result?.success) {
+                  console.error(`[${name}] Saved plan${result.path ? ` to: ${result.path}` : ''}`);
+                } else if (result) {
+                  console.error(`[${name}] Save failed: ${result.error}`);
                 }
               }
             } catch (err) {
@@ -319,6 +325,7 @@ export async function startPlannotatorServer(
               const body = (await req.json().catch(() => ({}))) as {
                 obsidian?: ObsidianConfig;
                 bear?: BearConfig;
+                octarine?: OctarineConfig;
                 feedback?: string;
                 agentSwitch?: string;
                 planSave?: { enabled: boolean; customPath?: string };
@@ -346,23 +353,25 @@ export async function startPlannotatorServer(
                 planSaveCustomPath = body.planSave.customPath;
               }
 
-              // Obsidian integration
+              // Run integrations in parallel — they're independent
+              const integrationResults: Record<string, IntegrationResult> = {};
+              const integrationPromises: Promise<void>[] = [];
               if (body.obsidian?.vaultPath && body.obsidian?.plan) {
-                const result = await saveToObsidian(body.obsidian);
-                if (result.success) {
-                  console.error(`[Obsidian] Saved plan to: ${result.path}`);
-                } else {
-                  console.error(`[Obsidian] Save failed: ${result.error}`);
-                }
+                integrationPromises.push(saveToObsidian(body.obsidian).then(r => { integrationResults.obsidian = r; }));
               }
-
-              // Bear integration
               if (body.bear?.plan) {
-                const result = await saveToBear(body.bear);
-                if (result.success) {
-                  console.error(`[Bear] Saved plan to Bear`);
-                } else {
-                  console.error(`[Bear] Save failed: ${result.error}`);
+                integrationPromises.push(saveToBear(body.bear).then(r => { integrationResults.bear = r; }));
+              }
+              if (body.octarine?.plan && body.octarine?.workspace) {
+                integrationPromises.push(saveToOctarine(body.octarine).then(r => { integrationResults.octarine = r; }));
+              }
+              await Promise.allSettled(integrationPromises);
+
+              for (const [name, result] of Object.entries(integrationResults)) {
+                if (result?.success) {
+                  console.error(`[${name}] Saved plan${result.path ? ` to: ${result.path}` : ''}`);
+                } else if (result) {
+                  console.error(`[${name}] Save failed: ${result.error}`);
                 }
               }
             } catch (err) {

packages/server/integrations.ts

@@ -23,6 +23,12 @@ export interface BearConfig {
   tagPosition?: 'prepend' | 'append';
 }
 
+export interface OctarineConfig {
+  plan: string;
+  workspace: string;
+  folder: string;
+}
+
 export interface IntegrationResult {
   success: boolean;
   error?: string;
@@ -320,3 +326,28 @@ export async function saveToBear(config: BearConfig): Promise<IntegrationResult>
     return { success: false, error: message };
   }
 }
+
+// --- Octarine Integration ---
+
+/**
+ * Save plan to Octarine using octarine:// URI scheme
+ */
+export async function saveToOctarine(config: OctarineConfig): Promise<IntegrationResult> {
+  try {
+    const { plan, workspace, folder } = config;
+
+    const filename = generateFilename(plan);
+    // Strip .md — Octarine auto-adds it
+    const basename = filename.replace(/\.md$/, '');
+    const path = folder ? `${folder}/${basename}` : basename;
+
+    const url = `octarine://create?path=${encodeURIComponent(path)}&content=${encodeURIComponent(plan)}&workspace=${encodeURIComponent(workspace)}&openAfter=false`;
+
+    await $`open ${url}`.quiet();
+
+    return { success: true, path };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    return { success: false, error: message };
+  }
+}