micode 0.8.4 → 0.8.5

package/src/hooks/auto-compact.ts

@@ -1,15 +1,11 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-import { getContextLimit } from "../utils/model-limits";
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 
-// Compact when this percentage of context is used
-const COMPACT_THRESHOLD = 0.5;
-
-const LEDGER_DIR = "thoughts/ledgers";
+import type { PluginInput } from "@opencode-ai/plugin";
 
-// Timeout for waiting for compaction to complete (2 minutes)
-const COMPACTION_TIMEOUT_MS = 120_000;
+import { config } from "../utils/config";
+import { extractErrorMessage } from "../utils/errors";
+import { getContextLimit } from "../utils/model-limits";
 
 interface PendingCompaction {
   resolve: () => void;
@@ -23,9 +19,6 @@ interface AutoCompactState {
   pendingCompactions: Map<string, PendingCompaction>;
 }
 
-// Cooldown between compaction attempts (prevent rapid re-triggering)
-const COMPACT_COOLDOWN_MS = 30_000; // 30 seconds
-
 export function createAutoCompactHook(ctx: PluginInput) {
   const state: AutoCompactState = {
     inProgress: new Set(),
@@ -65,13 +58,13 @@ export function createAutoCompactHook(ctx: PluginInput) {
       if (!summaryText.trim()) return;
 
       // Create ledger directory if needed
-      const ledgerDir = join(ctx.directory, LEDGER_DIR);
+      const ledgerDir = join(ctx.directory, config.paths.ledgerDir);
       await mkdir(ledgerDir, { recursive: true });
 
       // Write ledger file - summary is already structured (Factory.ai/pi-mono format)
       const timestamp = new Date().toISOString();
       const sessionName = sessionID.slice(0, 8); // Use first 8 chars of session ID
-      const ledgerPath = join(ledgerDir, `CONTINUITY_${sessionName}.md`);
+      const ledgerPath = join(ledgerDir, `${config.paths.ledgerPrefix}${sessionName}.md`);
 
       // Add metadata header, then the structured summary as-is
       const ledgerContent = `---
@@ -94,7 +87,7 @@ ${summaryText}
       const timeoutId = setTimeout(() => {
         state.pendingCompactions.delete(sessionID);
         reject(new Error("Compaction timed out"));
-      }, COMPACTION_TIMEOUT_MS);
+      }, config.compaction.timeoutMs);
 
       state.pendingCompactions.set(sessionID, { resolve, reject, timeoutId });
     });
@@ -112,7 +105,7 @@ ${summaryText}
 
     // Check cooldown
     const lastCompact = state.lastCompactTime.get(sessionID) || 0;
-    if (Date.now() - lastCompact < COMPACT_COOLDOWN_MS) {
+    if (Date.now() - lastCompact < config.compaction.cooldownMs) {
       return;
     }
 
@@ -120,7 +113,7 @@ ${summaryText}
 
     try {
       const usedPercent = Math.round(usageRatio * 100);
-      const thresholdPercent = Math.round(COMPACT_THRESHOLD * 100);
+      const thresholdPercent = Math.round(config.compaction.threshold * 100);
 
       await ctx.client.tui
         .showToast({
@@ -128,7 +121,7 @@ ${summaryText}
             title: "Auto Compacting",
             message: `Context at ${usedPercent}% (threshold: ${thresholdPercent}%). Summarizing...`,
             variant: "warning",
-            duration: 3000,
+            duration: config.timeouts.toastWarningMs,
           },
         })
         .catch(() => {});
@@ -158,19 +151,19 @@ ${summaryText}
             title: "Compaction Complete",
             message: "Session summarized and ledger updated.",
             variant: "success",
-            duration: 3000,
+            duration: config.timeouts.toastSuccessMs,
           },
         })
         .catch(() => {});
     } catch (e) {
-      const errorMsg = e instanceof Error ? e.message : String(e);
+      const errorMsg = extractErrorMessage(e);
       await ctx.client.tui
         .showToast({
           body: {
             title: "Compaction Failed",
             message: errorMsg.slice(0, 100),
             variant: "error",
-            duration: 5000,
+            duration: config.timeouts.toastErrorMs,
           },
         })
         .catch(() => {});
@@ -233,7 +226,7 @@ ${summaryText}
         const usageRatio = totalUsed / contextLimit;
 
         // Trigger compaction if over threshold
-        if (usageRatio >= COMPACT_THRESHOLD) {
+        if (usageRatio >= config.compaction.threshold) {
           triggerCompaction(sessionID, providerID, modelID, usageRatio);
         }
       }

package/src/hooks/context-injector.ts

@@ -1,12 +1,7 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import { readFile } from "node:fs/promises";
 import { join, dirname, resolve } from "node:path";
-
-// Files to inject at project root level (AGENTS.md and CLAUDE.md handled by OpenCode natively)
-const ROOT_CONTEXT_FILES = ["ARCHITECTURE.md", "CODE_STYLE.md", "README.md"] as const;
-
-// Files to collect when walking up directories (AGENTS.md handled by OpenCode natively)
-const DIRECTORY_CONTEXT_FILES = ["README.md"] as const;
+import { config } from "../utils/config";
 
 // Tools that trigger directory-aware context injection
 const FILE_ACCESS_TOOLS = ["Read", "read", "Edit", "edit"];
@@ -18,8 +13,6 @@ interface ContextCache {
   lastRootCheck: number;
 }
 
-const CACHE_TTL = 30_000; // 30 seconds
-
 export function createContextInjectorHook(ctx: PluginInput) {
   const cache: ContextCache = {
     rootContent: new Map(),
@@ -30,14 +23,14 @@ export function createContextInjectorHook(ctx: PluginInput) {
   async function loadRootContextFiles(): Promise<Map<string, string>> {
     const now = Date.now();
 
-    if (now - cache.lastRootCheck < CACHE_TTL && cache.rootContent.size > 0) {
+    if (now - cache.lastRootCheck < config.limits.contextCacheTtlMs && cache.rootContent.size > 0) {
       return cache.rootContent;
     }
 
     cache.rootContent.clear();
     cache.lastRootCheck = now;
 
-    for (const filename of ROOT_CONTEXT_FILES) {
+    for (const filename of config.paths.rootContextFiles) {
       try {
         const filepath = join(ctx.directory, filename);
         const content = await readFile(filepath, "utf-8");
@@ -67,7 +60,7 @@ export function createContextInjectorHook(ctx: PluginInput) {
 
     // Walk up from file directory to project root
     while (currentDir.startsWith(projectRoot) || currentDir === projectRoot) {
-      for (const filename of DIRECTORY_CONTEXT_FILES) {
+      for (const filename of config.paths.dirContextFiles) {
         const contextPath = join(currentDir, filename);
         const relPath = currentDir.replace(projectRoot, "").replace(/^\//, "") || ".";
         const key = `${relPath}/${filename}`;
@@ -98,7 +91,7 @@ export function createContextInjectorHook(ctx: PluginInput) {
     cache.directoryContent.set(cacheKey, collected);
 
     // Limit cache size
-    if (cache.directoryContent.size > 100) {
+    if (cache.directoryContent.size > config.limits.contextCacheMaxSize) {
       const firstKey = cache.directoryContent.keys().next().value;
       if (firstKey) cache.directoryContent.delete(firstKey);
     }
@@ -143,7 +136,7 @@ export function createContextInjectorHook(ctx: PluginInput) {
     ) => {
       if (!FILE_ACCESS_TOOLS.includes(input.tool)) return;
 
-      const filePath = input.args?.file_path as string | undefined;
+      const filePath = input.args?.filePath as string | undefined;
       if (!filePath) return;
 
       try {

package/src/hooks/context-window-monitor.ts

@@ -1,17 +1,12 @@
 import type { PluginInput } from "@opencode-ai/plugin";
+import { config } from "../utils/config";
 import { getContextLimit } from "../utils/model-limits";
 
-// Thresholds for context window warnings
-const WARNING_THRESHOLD = 0.7; // 70% - remind there's still room
-const CRITICAL_THRESHOLD = 0.85; // 85% - getting tight
-
 interface MonitorState {
   lastWarningTime: Map<string, number>;
   lastUsageRatio: Map<string, number>;
 }
 
-const WARNING_COOLDOWN_MS = 120_000; // 2 minutes between warnings
-
 export function createContextWindowMonitorHook(ctx: PluginInput) {
   const state: MonitorState = {
     lastWarningTime: new Map(),
@@ -21,11 +16,11 @@ export function createContextWindowMonitorHook(ctx: PluginInput) {
   function getEncouragementMessage(usageRatio: number): string {
     const remaining = Math.round((1 - usageRatio) * 100);
 
-    if (usageRatio < WARNING_THRESHOLD) {
+    if (usageRatio < config.contextWindow.warningThreshold) {
       return ""; // No message needed
     }
 
-    if (usageRatio < CRITICAL_THRESHOLD) {
+    if (usageRatio < config.contextWindow.criticalThreshold) {
       return `Context: ${remaining}% remaining. Plenty of room - don't rush.`;
     }
 
@@ -40,7 +35,7 @@ export function createContextWindowMonitorHook(ctx: PluginInput) {
     ) => {
       const usageRatio = state.lastUsageRatio.get(input.sessionID);
 
-      if (usageRatio && usageRatio >= WARNING_THRESHOLD) {
+      if (usageRatio && usageRatio >= config.contextWindow.warningThreshold) {
         const message = getEncouragementMessage(usageRatio);
         if (message && output.system) {
           output.system = `${output.system}\n\n<context-status>${message}</context-status>`;
@@ -80,13 +75,13 @@ export function createContextWindowMonitorHook(ctx: PluginInput) {
         state.lastUsageRatio.set(sessionID, usageRatio);
 
         // Show toast warning if threshold crossed
-        if (usageRatio >= WARNING_THRESHOLD) {
+        if (usageRatio >= config.contextWindow.warningThreshold) {
           const lastWarning = state.lastWarningTime.get(sessionID) || 0;
-          if (Date.now() - lastWarning > WARNING_COOLDOWN_MS) {
+          if (Date.now() - lastWarning > config.contextWindow.warningCooldownMs) {
             state.lastWarningTime.set(sessionID, Date.now());
 
             const remaining = Math.round((1 - usageRatio) * 100);
-            const variant = usageRatio >= CRITICAL_THRESHOLD ? "warning" : "info";
+            const variant = usageRatio >= config.contextWindow.criticalThreshold ? "warning" : "info";
 
             await ctx.client.tui
               .showToast({
@@ -94,7 +89,7 @@ export function createContextWindowMonitorHook(ctx: PluginInput) {
                   title: "Context Window",
                   message: `${remaining}% remaining (${Math.round(totalUsed / 1000)}K / ${Math.round(contextLimit / 1000)}K tokens)`,
                   variant,
-                  duration: 4000,
+                  duration: config.timeouts.toastWarningMs,
                 },
               })
               .catch(() => {});

package/src/hooks/ledger-loader.ts

@@ -2,9 +2,7 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import { readFile, readdir } from "node:fs/promises";
 import { join } from "node:path";
-
-const LEDGER_DIR = "thoughts/ledgers";
-const LEDGER_PREFIX = "CONTINUITY_";
+import { config } from "../utils/config";
 
 export interface LedgerInfo {
   sessionName: string;
@@ -13,11 +11,11 @@ export interface LedgerInfo {
 }
 
 export async function findCurrentLedger(directory: string): Promise<LedgerInfo | null> {
-  const ledgerDir = join(directory, LEDGER_DIR);
+  const ledgerDir = join(directory, config.paths.ledgerDir);
 
   try {
     const files = await readdir(ledgerDir);
-    const ledgerFiles = files.filter((f) => f.startsWith(LEDGER_PREFIX) && f.endsWith(".md"));
+    const ledgerFiles = files.filter((f) => f.startsWith(config.paths.ledgerPrefix) && f.endsWith(".md"));
 
     if (ledgerFiles.length === 0) return null;
 
@@ -40,7 +38,7 @@ export async function findCurrentLedger(directory: string): Promise<LedgerInfo |
 
     const filePath = join(ledgerDir, latestFile);
     const content = await readFile(filePath, "utf-8");
-    const sessionName = latestFile.replace(LEDGER_PREFIX, "").replace(".md", "");
+    const sessionName = latestFile.replace(config.paths.ledgerPrefix, "").replace(".md", "");
 
     return { sessionName, filePath, content };
   } catch {

package/src/hooks/token-aware-truncation.ts

@@ -1,23 +1,17 @@
 import type { PluginInput } from "@opencode-ai/plugin";
+import { config } from "../utils/config";
 
 // Tools that benefit from truncation
 const TRUNCATABLE_TOOLS = ["grep", "Grep", "glob", "Glob", "ast_grep_search"];
 
-// Token estimation (conservative: 4 chars = 1 token)
-const CHARS_PER_TOKEN = 4;
-const DEFAULT_CONTEXT_LIMIT = 200_000;
-const DEFAULT_MAX_OUTPUT_TOKENS = 50_000;
-const SAFETY_MARGIN = 0.5; // Keep 50% headroom
-const PRESERVE_HEADER_LINES = 3;
-
 function estimateTokens(text: string): number {
-  return Math.ceil(text.length / CHARS_PER_TOKEN);
+  return Math.ceil(text.length / config.tokens.charsPerToken);
 }
 
 function truncateToTokenLimit(
   output: string,
   maxTokens: number,
-  preserveLines: number = PRESERVE_HEADER_LINES,
+  preserveLines: number = config.tokens.preserveHeaderLines,
 ): string {
   const currentTokens = estimateTokens(output);
 
@@ -85,7 +79,7 @@ export function createTokenAwareTruncationHook(ctx: PluginInput) {
 
       const messages = (resp as { data?: unknown[] }).data;
       if (!Array.isArray(messages) || messages.length === 0) {
-        return { used: 0, limit: DEFAULT_CONTEXT_LIMIT };
+        return { used: 0, limit: config.tokens.defaultContextLimit };
       }
 
       // Find last assistant message with usage info
@@ -96,7 +90,7 @@ export function createTokenAwareTruncationHook(ctx: PluginInput) {
       }) as Record<string, unknown> | undefined;
 
       if (!lastAssistant) {
-        return { used: 0, limit: DEFAULT_CONTEXT_LIMIT };
+        return { used: 0, limit: config.tokens.defaultContextLimit };
       }
 
       const info = lastAssistant.info as Record<string, unknown> | undefined;
@@ -107,25 +101,25 @@ export function createTokenAwareTruncationHook(ctx: PluginInput) {
       const used = inputTokens + cacheRead;
 
       // Get model limit (simplified - use default for now)
-      const limit = DEFAULT_CONTEXT_LIMIT;
+      const limit = config.tokens.defaultContextLimit;
 
       const result = { used, limit };
       state.sessionTokenUsage.set(sessionID, result);
       return result;
     } catch {
-      return state.sessionTokenUsage.get(sessionID) || { used: 0, limit: DEFAULT_CONTEXT_LIMIT };
+      return state.sessionTokenUsage.get(sessionID) || { used: 0, limit: config.tokens.defaultContextLimit };
     }
   }
 
   function calculateMaxOutputTokens(used: number, limit: number): number {
     const remaining = limit - used;
-    const available = Math.floor(remaining * SAFETY_MARGIN);
+    const available = Math.floor(remaining * config.tokens.safetyMargin);
 
     if (available <= 0) {
       return 0;
     }
 
-    return Math.min(available, DEFAULT_MAX_OUTPUT_TOKENS);
+    return Math.min(available, config.tokens.defaultMaxOutputTokens);
   }
 
   return {
@@ -180,8 +174,8 @@ export function createTokenAwareTruncationHook(ctx: PluginInput) {
       } catch {
         // On error, apply static truncation as fallback
         const currentTokens = estimateTokens(output.output);
-        if (currentTokens > DEFAULT_MAX_OUTPUT_TOKENS) {
-          output.output = truncateToTokenLimit(output.output, DEFAULT_MAX_OUTPUT_TOKENS);
+        if (currentTokens > config.tokens.defaultMaxOutputTokens) {
+          output.output = truncateToTokenLimit(output.output, config.tokens.defaultMaxOutputTokens);
         }
       }
     },

package/src/index.ts

@@ -3,30 +3,28 @@ import type { McpLocalConfig } from "@opencode-ai/sdk";
 
 // Agents
 import { agents, PRIMARY_AGENT_NAME } from "./agents";
-
-// Tools
-import { ast_grep_search, ast_grep_replace, checkAstGrepAvailable } from "./tools/ast-grep";
-import { btca_ask, checkBtcaAvailable } from "./tools/btca";
-import { look_at } from "./tools/look-at";
-import { artifact_search } from "./tools/artifact-search";
-import { createSpawnAgentTool } from "./tools/spawn-agent";
-
+// Config loader
+import { loadMicodeConfig, mergeAgentConfigs } from "./config-loader";
+import { createArtifactAutoIndexHook } from "./hooks/artifact-auto-index";
 // Hooks
 import { createAutoCompactHook } from "./hooks/auto-compact";
+import { createCommentCheckerHook } from "./hooks/comment-checker";
 import { createContextInjectorHook } from "./hooks/context-injector";
-import { createSessionRecoveryHook } from "./hooks/session-recovery";
-import { createTokenAwareTruncationHook } from "./hooks/token-aware-truncation";
 import { createContextWindowMonitorHook } from "./hooks/context-window-monitor";
-import { createCommentCheckerHook } from "./hooks/comment-checker";
-import { createLedgerLoaderHook } from "./hooks/ledger-loader";
-import { createArtifactAutoIndexHook } from "./hooks/artifact-auto-index";
 import { createFileOpsTrackerHook, getFileOps } from "./hooks/file-ops-tracker";
-
+import { createLedgerLoaderHook } from "./hooks/ledger-loader";
+import { createSessionRecoveryHook } from "./hooks/session-recovery";
+import { createTokenAwareTruncationHook } from "./hooks/token-aware-truncation";
+import { artifact_search } from "./tools/artifact-search";
+// Tools
+import { ast_grep_replace, ast_grep_search, checkAstGrepAvailable } from "./tools/ast-grep";
+import { btca_ask, checkBtcaAvailable } from "./tools/btca";
+import { look_at } from "./tools/look-at";
+import { milestone_artifact_search } from "./tools/milestone-artifact-search";
+import { createOcttoTools, createSessionStore } from "./tools/octto";
 // PTY System
-import { PTYManager, createPtyTools } from "./tools/pty";
-
-// Config loader
-import { loadMicodeConfig, mergeAgentConfigs } from "./config-loader";
+import { createPtyTools, PTYManager } from "./tools/pty";
+import { createSpawnAgentTool } from "./tools/spawn-agent";
 
 // Think mode: detect keywords and enable extended thinking
 const THINK_KEYWORDS = [
@@ -75,7 +73,7 @@ const OpenCodeConfigPlugin: Plugin = async (ctx) => {
     console.warn(`[micode] ${btcaStatus.message}`);
   }
 
-  // Load user config for model overrides
+  // Load user config for temperature/maxTokens overrides (model overrides not supported)
   const userConfig = await loadMicodeConfig();
 
   // Think mode state per session
@@ -99,6 +97,28 @@ const OpenCodeConfigPlugin: Plugin = async (ctx) => {
   // Spawn agent tool (for subagents to spawn other subagents)
   const spawn_agent = createSpawnAgentTool(ctx);
 
+  // Octto (browser-based brainstorming) tools
+  const octtoSessionStore = createSessionStore();
+
+  // Track octto sessions per opencode session for cleanup
+  const octtoSessionsMap = new Map<string, Set<string>>();
+
+  const octtoTools = createOcttoTools(octtoSessionStore, ctx.client, {
+    onCreated: (parentSessionId, octtoSessionId) => {
+      const sessions = octtoSessionsMap.get(parentSessionId) ?? new Set<string>();
+      sessions.add(octtoSessionId);
+      octtoSessionsMap.set(parentSessionId, sessions);
+    },
+    onEnded: (parentSessionId, octtoSessionId) => {
+      const sessions = octtoSessionsMap.get(parentSessionId);
+      if (!sessions) return;
+      sessions.delete(octtoSessionId);
+      if (sessions.size === 0) {
+        octtoSessionsMap.delete(parentSessionId);
+      }
+    },
+  });
+
   return {
     // Tools
     tool: {
@@ -107,8 +127,10 @@ const OpenCodeConfigPlugin: Plugin = async (ctx) => {
       btca_ask,
       look_at,
       artifact_search,
+      milestone_artifact_search,
       spawn_agent,
       ...ptyTools,
+      ...octtoTools,
     },
 
     config: async (config) => {
@@ -292,12 +314,22 @@ IMPORTANT:
     },
 
     event: async ({ event }) => {
-      // Session cleanup (think mode + PTY)
+      // Session cleanup (think mode + PTY + octto)
       if (event.type === "session.deleted") {
         const props = event.properties as { info?: { id?: string } } | undefined;
         if (props?.info?.id) {
-          thinkModeState.delete(props.info.id);
-          ptyManager.cleanupBySession(props.info.id);
+          const sessionId = props.info.id;
+          thinkModeState.delete(sessionId);
+          ptyManager.cleanupBySession(sessionId);
+
+          // Cleanup octto sessions
+          const octtoSessions = octtoSessionsMap.get(sessionId);
+          if (octtoSessions) {
+            for (const octtoSessionId of octtoSessions) {
+              await octtoSessionStore.endSession(octtoSessionId).catch(() => {});
+            }
+            octtoSessionsMap.delete(sessionId);
+          }
         }
       }
 

package/src/indexing/milestone-artifact-classifier.ts

@@ -0,0 +1,26 @@
+export const MILESTONE_ARTIFACT_TYPES = {
+  FEATURE: "feature",
+  DECISION: "decision",
+  SESSION: "session",
+} as const;
+
+export type MilestoneArtifactType = (typeof MILESTONE_ARTIFACT_TYPES)[keyof typeof MILESTONE_ARTIFACT_TYPES];
+
+const FEATURE_HINTS = ["requirement", "implementation", "capability", "scope", "spec"];
+const DECISION_HINTS = ["decision", "decided", "trade-off", "rationale", "chosen"];
+const SESSION_HINTS = ["meeting", "status", "discussion", "notes", "update"];
+
+const matchesAny = (content: string, hints: string[]) => hints.some((hint) => content.includes(hint));
+
+export function classifyMilestoneArtifact(content: string): MilestoneArtifactType {
+  const normalized = content.toLowerCase();
+  const isFeature = matchesAny(normalized, FEATURE_HINTS);
+  const isDecision = matchesAny(normalized, DECISION_HINTS);
+  const isSession = matchesAny(normalized, SESSION_HINTS);
+
+  if (isFeature) return MILESTONE_ARTIFACT_TYPES.FEATURE;
+  if (isDecision) return MILESTONE_ARTIFACT_TYPES.DECISION;
+  if (isSession) return MILESTONE_ARTIFACT_TYPES.SESSION;
+
+  return MILESTONE_ARTIFACT_TYPES.SESSION;
+}

package/src/indexing/milestone-artifact-ingest.ts

@@ -0,0 +1,42 @@
+import { type ArtifactIndex, getArtifactIndex } from "../tools/artifact-index";
+import { log } from "../utils/logger";
+import {
+  classifyMilestoneArtifact,
+  MILESTONE_ARTIFACT_TYPES,
+  type MilestoneArtifactType,
+} from "./milestone-artifact-classifier";
+
+export interface MilestoneArtifactInput {
+  id: string;
+  milestoneId: string;
+  sourceSessionId?: string;
+  createdAt?: string;
+  tags?: string[];
+  payload: string;
+}
+
+export async function ingestMilestoneArtifact(
+  input: MilestoneArtifactInput,
+  index?: ArtifactIndex,
+  classifier: (content: string) => MilestoneArtifactType = classifyMilestoneArtifact,
+): Promise<void> {
+  const artifactIndex = index ?? (await getArtifactIndex());
+  let artifactType: MilestoneArtifactType;
+
+  try {
+    artifactType = classifier(input.payload);
+  } catch (error) {
+    log.error("milestone-ingest", "Failed to classify milestone artifact, defaulting to session", error);
+    artifactType = MILESTONE_ARTIFACT_TYPES.SESSION;
+  }
+
+  await artifactIndex.indexMilestoneArtifact({
+    id: input.id,
+    milestoneId: input.milestoneId,
+    artifactType,
+    sourceSessionId: input.sourceSessionId,
+    createdAt: input.createdAt,
+    tags: input.tags,
+    payload: input.payload,
+  });
+}

package/src/octto/constants.ts

@@ -0,0 +1,20 @@
+// src/octto/constants.ts
+// Re-exports from centralized config for backward compatibility
+// Single source of truth is in src/utils/config.ts
+
+import { config } from "../utils/config";
+
+/** Default timeout for waiting for user answers (5 minutes) */
+export const DEFAULT_ANSWER_TIMEOUT_MS = config.octto.answerTimeoutMs;
+
+/** Default maximum number of follow-up questions per branch */
+export const DEFAULT_MAX_QUESTIONS = config.octto.maxQuestions;
+
+/** Default timeout for brainstorm review (10 minutes) */
+export const DEFAULT_REVIEW_TIMEOUT_MS = config.octto.reviewTimeoutMs;
+
+/** Maximum number of brainstorm iterations */
+export const MAX_ITERATIONS = config.octto.maxIterations;
+
+/** Directory for persisting brainstorm state files */
+export const STATE_DIR = config.octto.stateDir;

package/src/octto/session/browser.ts

@@ -0,0 +1,32 @@
+// src/octto/session/browser.ts
+// Cross-platform browser opener
+
+/**
+ * Opens the default browser to the specified URL.
+ * Detects platform and uses appropriate command.
+ */
+export async function openBrowser(url: string): Promise<void> {
+  const platform = process.platform;
+
+  let command: string[];
+
+  switch (platform) {
+    case "darwin":
+      command = ["open", url];
+      break;
+    case "win32":
+      command = ["cmd", "/c", "start", url];
+      break;
+    default:
+      // Linux and others
+      command = ["xdg-open", url];
+      break;
+  }
+
+  const proc = Bun.spawn(command, {
+    stdout: "ignore",
+    stderr: "ignore",
+  });
+
+  await proc.exited;
+}

package/src/octto/session/index.ts

@@ -0,0 +1,25 @@
+// src/octto/session/index.ts
+export type { SessionStore, SessionStoreOptions } from "./sessions";
+export { createSessionStore } from "./sessions";
+export type {
+  Answer,
+  AskCodeAnswer,
+  AskFileAnswer,
+  AskImageAnswer,
+  AskTextAnswer,
+  BaseConfig,
+  ConfirmAnswer,
+  EmojiReactAnswer,
+  PickManyAnswer,
+  PickOneAnswer,
+  QuestionAnswers,
+  QuestionConfig,
+  QuestionType,
+  RankAnswer,
+  RateAnswer,
+  ReviewAnswer,
+  ShowOptionsAnswer,
+  SliderAnswer,
+  ThumbsAnswer,
+} from "./types";
+export { QUESTION_TYPES, QUESTIONS, STATUSES, WS_MESSAGES } from "./types";