@jmylchreest/aide-plugin 0.0.42 → 0.0.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jmylchreest/aide-plugin",
-  "version": "0.0.42",
+  "version": "0.0.43",
   "description": "aide plugin for OpenCode — multi-agent orchestration, memory, skills, and persistence",
   "type": "module",
   "main": "./src/opencode/index.ts",

package/skills/context-usage/SKILL.md

@@ -0,0 +1,157 @@
+---
+name: context-usage
+description: Analyze current session context and token usage from OpenCode SQLite database
+platforms:
+  - opencode
+triggers:
+  - context usage
+  - token usage
+  - session stats
+  - how much context
+  - context budget
+  - how big is this session
+  - session size
+---
+
+# Context Usage Analysis
+
+**Recommended model tier:** balanced (sonnet) - straightforward SQL queries
+
+Analyze the current session's context window consumption, tool usage breakdown,
+and token costs by querying the OpenCode SQLite database directly.
+
+## Prerequisites
+
+- This skill **only works on OpenCode**. Verify by checking the environment:
+  - `$OPENCODE=1` — set by the OpenCode runtime
+  - `$AIDE_PLATFORM=opencode` — set by aide when running under OpenCode
+  - `$AIDE_SESSION_ID` — the current session ID (injected by aide)
+- The OpenCode database is at `~/.local/share/opencode/opencode.db`.
+- `sqlite3` must be available on the system.
+
+If `$OPENCODE` is not `1` or `$AIDE_PLATFORM` is not `opencode`, abort immediately
+and inform the user that this skill is only supported on OpenCode.
+Do **not** attempt to query other databases (e.g. Claude Code's storage) — the
+schema is OpenCode-specific.
+
+If `$AIDE_SESSION_ID` is not set, abort with a message explaining that the
+session ID could not be determined.
+
+## Workflow
+
+Run the following queries **sequentially** in a single Bash call (chain with `&&`).
+Present results to the user in a formatted summary after all queries complete.
+
+### Step 1: Validate environment
+
+```bash
+test "$OPENCODE" = "1" && echo "Platform: OpenCode" || echo "ERROR: Not running on OpenCode (OPENCODE=$OPENCODE)"
+test "$AIDE_PLATFORM" = "opencode" && echo "AIDE Platform: opencode" || echo "WARNING: AIDE_PLATFORM=$AIDE_PLATFORM"
+test -n "$AIDE_SESSION_ID" && echo "Session: $AIDE_SESSION_ID" || echo "ERROR: AIDE_SESSION_ID not set"
+```
+
+If `OPENCODE` is not `1`, stop immediately — this skill cannot work outside OpenCode.
+If `AIDE_SESSION_ID` is not set, stop and inform the user.
+
+### Step 2: Session overview
+
+```bash
+sqlite3 ~/.local/share/opencode/opencode.db "
+SELECT
+  s.title,
+  s.slug,
+  ROUND((julianday('now') - julianday(datetime(s.time_created/1000, 'unixepoch'))) * 24, 1) as hours_old,
+  (SELECT COUNT(*) FROM message m WHERE m.session_id = s.id) as messages,
+  CASE WHEN s.time_compacting IS NOT NULL THEN 'yes' ELSE 'no' END as compacted
+FROM session s
+WHERE s.id = '$AIDE_SESSION_ID';
+"
+```
+
+### Step 3: Token totals
+
+Sum tokens from `step-finish` parts (each represents one LLM turn):
+
+```bash
+sqlite3 ~/.local/share/opencode/opencode.db "
+SELECT
+  SUM(json_extract(data, '$.tokens.input')) as input_tokens,
+  SUM(json_extract(data, '$.tokens.output')) as output_tokens,
+  SUM(json_extract(data, '$.tokens.cache.read')) as cache_read_tokens,
+  SUM(json_extract(data, '$.tokens.cache.write')) as cache_write_tokens,
+  SUM(json_extract(data, '$.tokens.total')) as total_tokens,
+  COUNT(*) as llm_turns
+FROM part
+WHERE session_id = '$AIDE_SESSION_ID'
+  AND json_extract(data, '$.type') = 'step-finish';
+"
+```
+
+### Step 4: Tool output breakdown
+
+Show tool usage ranked by total output size:
+
+```bash
+sqlite3 ~/.local/share/opencode/opencode.db "
+SELECT
+  json_extract(data, '$.tool') as tool,
+  COUNT(*) as calls,
+  SUM(length(json_extract(data, '$.state.output'))) as total_output_bytes,
+  ROUND(AVG(length(json_extract(data, '$.state.output')))) as avg_bytes,
+  MAX(length(json_extract(data, '$.state.output'))) as max_bytes
+FROM part
+WHERE session_id = '$AIDE_SESSION_ID'
+  AND json_extract(data, '$.type') = 'tool'
+GROUP BY tool
+ORDER BY total_output_bytes DESC;
+"
+```
+
+### Step 5: Total session size
+
+```bash
+sqlite3 ~/.local/share/opencode/opencode.db "
+SELECT
+  SUM(length(json_extract(data, '$.state.output'))) as tool_output_bytes,
+  SUM(length(json_extract(data, '$.state.input'))) as tool_input_bytes,
+  SUM(length(data)) as total_part_bytes
+FROM part
+WHERE session_id = '$AIDE_SESSION_ID'
+  AND json_extract(data, '$.type') = 'tool';
+"
+```
+
+## Output Format
+
+Present the results as a structured summary:
+
+```
+## Session Context Usage
+
+**Session:** <title> (<slug>)
+**Age:** <hours> hours | **Messages:** <count> | **Compacted:** yes/no
+
+### Token Usage
+| Metric | Count |
+|--------|-------|
+| Input tokens | <n> |
+| Output tokens | <n> |
+| Cache read | <n> |
+| Cache write | <n> |
+| **Total tokens** | **<n>** |
+| LLM turns | <n> |
+
+### Tool Output Breakdown (by total bytes)
+| Tool | Calls | Total Output | Avg/call | Max |
+|------|-------|-------------|----------|-----|
+| ... | ... | ... | ... | ... |
+
+### Session Size
+- Tool outputs: <n> KB
+- Tool inputs: <n> KB
+- Total part storage: <n> KB (includes JSON metadata overhead)
+```
+
+Format byte values as KB (divide by 1024, round to 1 decimal).
+Highlight the top 3 tools by total output as the biggest context consumers.
+If any single tool call exceeds 20KB, flag it as a potential optimization target.

package/src/core/context-pruning/dedup.ts

@@ -0,0 +1,173 @@
+/**
+ * Dedup strategy: replace repeated identical tool outputs with a short pointer.
+ *
+ * Safe-to-dedup tools: Read (with mtime check), Glob, Grep, and aide MCP tools
+ * like code_search, code_symbols, code_outline, code_references,
+ * findings_list, findings_search, memory_list, memory_search.
+ *
+ * NEVER dedup: Bash, Write, Edit, or any tool with side effects.
+ */
+
+import type { PruneResult, PruneStrategy, ToolRecord } from "./types.js";
+import { statSync } from "fs";
+import { resolve, isAbsolute } from "path";
+
+/** Tools that are safe to deduplicate. */
+const SAFE_DEDUP_TOOLS = new Set([
+  // Host built-in read-only tools
+  "read",
+  "glob",
+  "grep",
+  // aide MCP tools (read-only)
+  "mcp__aide__code_search",
+  "mcp__aide__code_symbols",
+  "mcp__aide__code_outline",
+  "mcp__aide__code_references",
+  "mcp__aide__code_stats",
+  "mcp__aide__findings_list",
+  "mcp__aide__findings_search",
+  "mcp__aide__findings_stats",
+  "mcp__aide__memory_list",
+  "mcp__aide__memory_search",
+  "mcp__aide__decision_list",
+  "mcp__aide__decision_get",
+  "mcp__aide__decision_history",
+  "mcp__aide__state_get",
+  "mcp__aide__state_list",
+  "mcp__aide__task_list",
+  "mcp__aide__task_get",
+  "mcp__aide__message_list",
+  // Claude Code naming convention (no mcp__ prefix)
+  "code_search",
+  "code_symbols",
+  "code_outline",
+  "code_references",
+  "code_stats",
+  "findings_list",
+  "findings_search",
+  "findings_stats",
+  "memory_list",
+  "memory_search",
+  "decision_list",
+  "decision_get",
+  "decision_history",
+  "state_get",
+  "state_list",
+  "task_list",
+  "task_get",
+  "message_list",
+]);
+
+/** Extract the dedup key from tool args (the args that define "same call"). */
+function dedupKey(toolName: string, args: Record<string, unknown>): string {
+  const normalized = toolName.toLowerCase();
+  // For Read, the key is filePath + offset + limit
+  if (normalized === "read") {
+    return JSON.stringify({
+      tool: "read",
+      filePath: args.filePath ?? args.file_path ?? args.path,
+      offset: args.offset ?? 0,
+      limit: args.limit ?? 2000,
+    });
+  }
+  // For Glob, the key is pattern + path
+  if (normalized === "glob") {
+    return JSON.stringify({
+      tool: "glob",
+      pattern: args.pattern,
+      path: args.path,
+    });
+  }
+  // For Grep, the key is pattern + path + include
+  if (normalized === "grep") {
+    return JSON.stringify({
+      tool: "grep",
+      pattern: args.pattern,
+      path: args.path,
+      include: args.include,
+    });
+  }
+  // For MCP tools, use all args as the key
+  return JSON.stringify({ tool: normalized, ...args });
+}
+
+/** Check file mtime for Read dedup safety. */
+function getFileMtime(
+  args: Record<string, unknown>,
+  cwd?: string,
+): number | undefined {
+  const filePath =
+    (args.filePath as string) ??
+    (args.file_path as string) ??
+    (args.path as string);
+  if (!filePath) return undefined;
+
+  try {
+    const resolved = isAbsolute(filePath)
+      ? filePath
+      : resolve(cwd || process.cwd(), filePath);
+    return statSync(resolved).mtimeMs;
+  } catch {
+    return undefined;
+  }
+}
+
+export class DedupStrategy implements PruneStrategy {
+  name = "dedup" as const;
+  private cwd?: string;
+
+  constructor(cwd?: string) {
+    this.cwd = cwd;
+  }
+
+  apply(
+    toolName: string,
+    args: Record<string, unknown>,
+    output: string,
+    history: ToolRecord[],
+  ): PruneResult {
+    const normalized = toolName.toLowerCase();
+
+    // Only apply to safe tools
+    if (!SAFE_DEDUP_TOOLS.has(normalized)) {
+      return { output, modified: false, bytesSaved: 0 };
+    }
+
+    const key = dedupKey(toolName, args);
+
+    // Find the most recent matching call in history
+    for (let i = history.length - 1; i >= 0; i--) {
+      const prev = history[i];
+      const prevKey = dedupKey(prev.toolName, prev.args);
+
+      if (prevKey !== key) continue;
+
+      // For Read: check mtime hasn't changed (file might have been edited)
+      if (normalized === "read") {
+        const currentMtime = getFileMtime(args, this.cwd);
+        if (
+          currentMtime !== undefined &&
+          prev.fileMtime !== undefined &&
+          currentMtime !== prev.fileMtime
+        ) {
+          // File changed — don't dedup
+          continue;
+        }
+      }
+
+      // Check if output is identical
+      const prevOutput = prev.prunedOutput ?? prev.originalOutput;
+      if (output === prevOutput) {
+        const replacement = `[aide:dedup] Identical to previous ${toolName} call (callId: ${prev.callId}). Output unchanged.`;
+        return {
+          output: replacement,
+          modified: true,
+          strategy: "dedup",
+          bytesSaved: output.length - replacement.length,
+        };
+      }
+    }
+
+    return { output, modified: false, bytesSaved: 0 };
+  }
+}

package/src/core/context-pruning/index.ts

@@ -0,0 +1,19 @@
+/**
+ * Context Pruning — reduces context/token usage by deduplicating,
+ * superseding, and purging tool outputs.
+ *
+ * Platform adapters integrate via the ContextPruningTracker:
+ * - OpenCode: tool.execute.after hook modifies output.output
+ * - Claude Code: PostToolUse hook returns updatedMCPToolOutput
+ */
+
+export { ContextPruningTracker } from "./tracker.js";
+export { DedupStrategy } from "./dedup.js";
+export { SupersedeStrategy } from "./supersede.js";
+export { PurgeErrorsStrategy } from "./purge.js";
+export type {
+  ToolRecord,
+  PruneResult,
+  PruneStrategy,
+  PruningStats,
+} from "./types.js";

package/src/core/context-pruning/purge.ts

@@ -0,0 +1,80 @@
+/**
+ * Purge-errors strategy: replace large error outputs (stack traces, build
+ * failures) with a compact summary.
+ *
+ * When a Bash command fails and produces a large error output, most of the
+ * context is stack frames that aren't useful for the model. This strategy
+ * trims the output to the first meaningful error lines.
+ */
+
+import type { PruneResult, PruneStrategy, ToolRecord } from "./types.js";
+
+/** Minimum output size to trigger purging (2KB). */
+const MIN_SIZE_FOR_PURGE = 2048;
+
+/** Max lines to keep from an error output. */
+const MAX_ERROR_LINES = 30;
+
+/** Patterns that indicate an error output. */
+const ERROR_PATTERNS = [
+  /^error/im,
+  /^ERR!/im,
+  /exit code [1-9]/i,
+  /FAILED/i,
+  /panic:/i,
+  /Traceback/i,
+  /^Exception/im,
+  /compilation failed/i,
+  /build failed/i,
+  /TypeError:/,
+  /SyntaxError:/,
+  /ReferenceError:/,
+];
+
+export class PurgeErrorsStrategy implements PruneStrategy {
+  name = "purge" as const;
+
+  apply(
+    toolName: string,
+    _args: Record<string, unknown>,
+    output: string,
+    _history: ToolRecord[],
+  ): PruneResult {
+    const normalized = toolName.toLowerCase();
+
+    // Only apply to Bash output
+    if (normalized !== "bash") {
+      return { output, modified: false, bytesSaved: 0 };
+    }
+
+    // Only purge if output is large enough to matter
+    if (output.length < MIN_SIZE_FOR_PURGE) {
+      return { output, modified: false, bytesSaved: 0 };
+    }
+
+    // Check if output looks like an error
+    const isError = ERROR_PATTERNS.some((p) => p.test(output));
+    if (!isError) {
+      return { output, modified: false, bytesSaved: 0 };
+    }
+
+    // Trim to first MAX_ERROR_LINES lines + a note
+    const lines = output.split("\n");
+    if (lines.length <= MAX_ERROR_LINES) {
+      return { output, modified: false, bytesSaved: 0 };
+    }
+
+    const kept = lines.slice(0, MAX_ERROR_LINES).join("\n");
+    const trimmedCount = lines.length - MAX_ERROR_LINES;
+    const replacement =
+      kept +
+      `\n\n[aide:purge] ... ${trimmedCount} additional error lines trimmed. Re-run the command to see full output.`;
+
+    return {
+      output: replacement,
+      modified: true,
+      strategy: "purge",
+      bytesSaved: output.length - replacement.length,
+    };
+  }
+}

package/src/core/context-pruning/supersede.ts

@@ -0,0 +1,67 @@
+/**
+ * Supersede strategy: when a Write or Edit completes, mark prior Read outputs
+ * of the same file as stale so the model doesn't rely on outdated content.
+ *
+ * This doesn't replace the current tool output — it annotates previous Read
+ * records so that if they're re-read (dedup check), the stale content is flagged.
+ *
+ * For now, this strategy only adds a note to the current Write/Edit output
+ * reminding the model that prior reads of this file are now stale.
+ */
+
+import type { PruneResult, PruneStrategy, ToolRecord } from "./types.js";
+
+/** Tools that supersede prior reads. */
+const WRITE_TOOLS = new Set(["write", "edit"]);
+
+/** Extract the file path from tool args. */
+function getFilePath(args: Record<string, unknown>): string | undefined {
+  return (
+    (args.filePath as string) ??
+    (args.file_path as string) ??
+    (args.path as string) ??
+    undefined
+  );
+}
+
+export class SupersedeStrategy implements PruneStrategy {
+  name = "supersede" as const;
+
+  apply(
+    toolName: string,
+    args: Record<string, unknown>,
+    output: string,
+    history: ToolRecord[],
+  ): PruneResult {
+    const normalized = toolName.toLowerCase();
+
+    if (!WRITE_TOOLS.has(normalized)) {
+      return { output, modified: false, bytesSaved: 0 };
+    }
+
+    const filePath = getFilePath(args);
+    if (!filePath) {
+      return { output, modified: false, bytesSaved: 0 };
+    }
+
+    // Check if there are prior Read calls for this same file
+    const priorReads = history.filter((rec) => {
+      if (rec.toolName.toLowerCase() !== "read") return false;
+      const recPath = getFilePath(rec.args);
+      return recPath === filePath;
+    });
+
+    if (priorReads.length === 0) {
+      return { output, modified: false, bytesSaved: 0 };
+    }
+
+    // Annotate: prior reads of this file are now stale
+    const note = `\n[aide:supersede] Note: ${priorReads.length} prior Read(s) of "${filePath}" are now stale after this ${toolName}. Re-read if you need current content.`;
+    return {
+      output: output + note,
+      modified: true,
+      strategy: "supersede",
+      bytesSaved: 0, // We're adding, not saving bytes
+    };
+  }
+}

package/src/core/context-pruning/tracker.ts

@@ -0,0 +1,179 @@
+/**
+ * Context Pruning Tracker
+ *
+ * Orchestrates pruning strategies against tool outputs to reduce context usage.
+ * Platform adapters (OpenCode hooks, Claude Code PostToolUse) call into this
+ * tracker after each tool completes.
+ *
+ * The tracker maintains a history of tool invocations per session and applies
+ * strategies in order: dedup → supersede → purge-errors.
+ */
+
+import type {
+  PruneResult,
+  PruneStrategy,
+  PruningStats,
+  ToolRecord,
+} from "./types.js";
+import { DedupStrategy } from "./dedup.js";
+import { SupersedeStrategy } from "./supersede.js";
+import { PurgeErrorsStrategy } from "./purge.js";
+
+export class ContextPruningTracker {
+  private history: ToolRecord[] = [];
+  private strategies: PruneStrategy[];
+  private stats: PruningStats = {
+    totalCalls: 0,
+    prunedCalls: 0,
+    totalBytesSaved: 0,
+    estimatedContextBytes: 0,
+  };
+
+  /** Max history entries to keep (prevents unbounded growth). */
+  private maxHistory: number;
+
+  constructor(cwd?: string, maxHistory = 200) {
+    this.maxHistory = maxHistory;
+    this.strategies = [
+      new DedupStrategy(cwd),
+      new SupersedeStrategy(),
+      new PurgeErrorsStrategy(),
+    ];
+  }
+
+  /**
+   * Load existing history (for process-per-invocation environments like Claude Code).
+   * Merges with any existing in-memory history.
+   */
+  loadHistory(records: ToolRecord[]): void {
+    this.history = records.slice(-this.maxHistory);
+    // Recompute stats from loaded history
+    this.stats.totalCalls = this.history.length;
+    this.stats.prunedCalls = this.history.filter(
+      (r) => r.prunedOutput !== null,
+    ).length;
+    this.stats.estimatedContextBytes = this.history.reduce(
+      (sum, r) => sum + (r.prunedOutput ?? r.originalOutput).length,
+      0,
+    );
+    this.stats.totalBytesSaved = this.history.reduce(
+      (sum, r) =>
+        sum +
+        (r.prunedOutput !== null
+          ? r.originalOutput.length - r.prunedOutput.length
+          : 0),
+      0,
+    );
+  }
+
+  /** Get the current history (for persistence). */
+  getHistory(): ToolRecord[] {
+    return [...this.history];
+  }
+
+  /**
+   * Process a tool output through all pruning strategies.
+   * Returns the (possibly modified) output and metadata.
+   */
+  process(
+    callId: string,
+    toolName: string,
+    args: Record<string, unknown>,
+    output: string,
+  ): PruneResult {
+    this.stats.totalCalls++;
+
+    // Apply strategies in order — first match wins
+    let result: PruneResult = { output, modified: false, bytesSaved: 0 };
+
+    for (const strategy of this.strategies) {
+      result = strategy.apply(toolName, args, output, this.history);
+      if (result.modified) {
+        this.stats.prunedCalls++;
+        this.stats.totalBytesSaved += result.bytesSaved;
+        break;
+      }
+    }
+
+    // Track context size
+    this.stats.estimatedContextBytes += result.output.length;
+
+    // Record this call in history
+    const record: ToolRecord = {
+      callId,
+      toolName,
+      args,
+      originalOutput: output,
+      prunedOutput: result.modified ? result.output : null,
+      timestamp: Date.now(),
+    };
+
+    // For Read tools, record file mtime for dedup safety
+    if (toolName.toLowerCase() === "read") {
+      const filePath =
+        (args.filePath as string) ??
+        (args.file_path as string) ??
+        (args.path as string);
+      if (filePath) {
+        try {
+          const { statSync } = require("fs");
+          const { resolve, isAbsolute } = require("path");
+          const resolved = isAbsolute(filePath)
+            ? filePath
+            : resolve(process.cwd(), filePath);
+          record.fileMtime = statSync(resolved).mtimeMs;
+        } catch {
+          // File may not exist (e.g., directory read)
+        }
+      }
+    }
+
+    this.history.push(record);
+
+    // Trim history if needed
+    if (this.history.length > this.maxHistory) {
+      this.history = this.history.slice(-this.maxHistory);
+    }
+
+    return result;
+  }
+
+  /** Get current pruning stats (for context pressure signal). */
+  getStats(): PruningStats {
+    return { ...this.stats };
+  }
+
+  /**
+   * Get a context pressure value (0.0 - 1.0).
+   * This is a heuristic based on estimated context bytes and pruning ratio.
+   * Higher values mean more context pressure.
+   */
+  getContextPressure(): number {
+    // Use 128K tokens ≈ 512KB as a rough "full context" estimate
+    const estimatedCapacity = 512 * 1024;
+    const usageRatio = Math.min(
+      1.0,
+      this.stats.estimatedContextBytes / estimatedCapacity,
+    );
+
+    // If we're pruning a lot, that's also a pressure signal
+    const pruneRatio =
+      this.stats.totalCalls > 0
+        ? this.stats.prunedCalls / this.stats.totalCalls
+        : 0;
+
+    // Weighted: 70% usage, 30% prune ratio
+    return Math.min(1.0, usageRatio * 0.7 + pruneRatio * 0.3);
+  }
+
+  /** Clear history (e.g., on compaction). */
+  reset(): void {
+    this.history = [];
+    this.stats = {
+      totalCalls: 0,
+      prunedCalls: 0,
+      totalBytesSaved: 0,
+      estimatedContextBytes: 0,
+    };
+  }
+}

package/src/core/context-pruning/types.ts

@@ -0,0 +1,63 @@
+/**
+ * Context pruning types.
+ *
+ * These types define the contract between the platform-agnostic pruning logic
+ * and the platform-specific adapters (OpenCode hooks, Claude Code PostToolUse).
+ */
+
+/** A recorded tool use with its output, used for dedup tracking. */
+export interface ToolRecord {
+  /** Unique ID for this tool invocation (callID from host). */
+  callId: string;
+  /** Tool name (e.g. "Read", "Glob", "mcp__aide__code_search"). */
+  toolName: string;
+  /** Key arguments that define the "identity" of this call. */
+  args: Record<string, unknown>;
+  /** The original tool output (before any pruning). */
+  originalOutput: string;
+  /** The pruned output (after dedup/supersede applied), or null if unchanged. */
+  prunedOutput: string | null;
+  /** Timestamp of the tool invocation. */
+  timestamp: number;
+  /** File mtime at time of call (for Read dedup safety). */
+  fileMtime?: number;
+}
+
+/** Result of applying pruning strategies to a tool output. */
+export interface PruneResult {
+  /** The (possibly modified) output string. */
+  output: string;
+  /** Whether the output was modified. */
+  modified: boolean;
+  /** Which strategy modified it, if any. */
+  strategy?: "dedup" | "supersede" | "purge";
+  /** Bytes saved (original - pruned). */
+  bytesSaved: number;
+}
+
+/** Strategy interface — each strategy gets the current call + history. */
+export interface PruneStrategy {
+  name: string;
+  /**
+   * Evaluate whether this strategy should prune the given tool output.
+   * Returns a PruneResult with the potentially modified output.
+   */
+  apply(
+    toolName: string,
+    args: Record<string, unknown>,
+    output: string,
+    history: ToolRecord[],
+  ): PruneResult;
+}
+
+/** Running stats for the context pressure signal. */
+export interface PruningStats {
+  /** Total tool invocations tracked. */
+  totalCalls: number;
+  /** Total tool invocations that were pruned. */
+  prunedCalls: number;
+  /** Total bytes saved by pruning. */
+  totalBytesSaved: number;
+  /** Estimated total bytes of tool output in context. */
+  estimatedContextBytes: number;
+}

package/src/core/session-init.ts

@@ -194,12 +194,11 @@ export function initializeSession(
     agentCount: 0,
   };
 
-  const statePath = join(cwd, ".aide", "state", "session.json");
-  try {
-    writeFileSync(statePath, JSON.stringify(state, null, 2));
-  } catch {
-    // Ignore
-  }
+  // Session state is kept in-memory only (returned to the caller).
+  // We no longer write .aide/state/session.json — this eliminates a race
+  // condition where concurrent sessions would overwrite each other's file.
+  // Callers that need startedAt (e.g. getSessionCommits) receive it as a
+  // parameter from the in-memory SessionState or use a fallback default.
 
   return state;
 }
@@ -314,6 +313,7 @@ export function runSessionInit(
 
     result.static.global = data.global_memories.map((m) => m.content);
     result.static.project = data.project_memories.map((m) => m.content);
+    result.static.projectOverflow = data.project_memory_overflow ?? false;
     result.static.decisions = data.decisions.map(
       (d) =>
         `**${d.topic}**: ${d.value}${d.rationale ? ` (${d.rationale})` : ""}`,
@@ -426,6 +426,12 @@ export function buildWelcomeContext(
     for (const mem of memories.static.project) {
       lines.push(`- ${mem}`);
     }
+    if (memories.static.projectOverflow) {
+      lines.push("");
+      lines.push(
+        "_More project memories exist. Use `memory_search` to find specific context._",
+      );
+    }
     lines.push("");
   }
 

package/src/core/session-summary-logic.ts

@@ -7,23 +7,22 @@
 
 import { execFileSync } from "child_process";
 import { readFileSync, existsSync } from "fs";
-import { join } from "path";
 
 /**
- * Get git commits made during this session
+ * Get git commits made during this session.
+ *
+ * @param cwd - Working directory
+ * @param startedAt - ISO timestamp of when the session started. When provided,
+ *   scopes `git log --since` to this time. When omitted, falls back to "4 hours ago"
+ *   as a reasonable default for a single coding session.
  */
-export function getSessionCommits(cwd: string): string[] {
+export function getSessionCommits(cwd: string, startedAt?: string): string[] {
   try {
-    const sessionPath = join(cwd, ".aide", "state", "session.json");
-    if (!existsSync(sessionPath)) return [];
-
-    const sessionData = JSON.parse(readFileSync(sessionPath, "utf-8"));
-    const startedAt = sessionData.startedAt;
-    if (!startedAt) return [];
+    const sinceArg = startedAt || "4 hours ago";
 
     const output = execFileSync(
       "git",
-      ["log", "--oneline", `--since=${startedAt}`],
+      ["log", "--oneline", `--since=${sinceArg}`],
       {
         cwd,
         encoding: "utf-8",
@@ -52,6 +51,7 @@ export function getSessionCommits(cwd: string): string[] {
 export function buildSessionSummary(
   transcriptPath: string,
   cwd: string,
+  startedAt?: string,
 ): string | null {
   if (!existsSync(transcriptPath)) return null;
 
@@ -120,7 +120,7 @@ export function buildSessionSummary(
       }
     }
 
-    const commits = getSessionCommits(cwd);
+    const commits = getSessionCommits(cwd, startedAt);
 
     if (
       filesModified.size === 0 &&
@@ -170,8 +170,11 @@ export function buildSessionSummary(
  *
  * Uses aide state and git history instead of transcript parsing.
  */
-export function buildSessionSummaryFromState(cwd: string): string | null {
-  const commits = getSessionCommits(cwd);
+export function buildSessionSummaryFromState(
+  cwd: string,
+  startedAt?: string,
+): string | null {
+  const commits = getSessionCommits(cwd, startedAt);
 
   const summaryParts: string[] = [];
 

package/src/core/skill-matcher.ts

@@ -11,14 +11,9 @@ import { homedir } from "os";
 import type { Skill, SkillMatchResult } from "./types.js";
 
 // Skill search locations relative to cwd
-const SKILL_LOCATIONS = [
-  ".aide/skills",
-  "skills",
-];
+const SKILL_LOCATIONS = [".aide/skills", "skills"];
 
-const GLOBAL_SKILL_LOCATIONS = [
-  join(homedir(), ".aide", "skills"),
-];
+const GLOBAL_SKILL_LOCATIONS = [join(homedir(), ".aide", "skills")];
 
 /**
  * Calculate Levenshtein distance between two strings
@@ -120,6 +115,20 @@ export function parseSkillFrontmatter(
   }
   meta.triggers = triggers;
 
+  // Parse platforms array (e.g. "platforms:\n  - opencode")
+  const platforms: string[] = [];
+  const platformMatch = yamlContent.match(/platforms:\s*\n((?:\s+-\s*.+\n?)*)/);
+  if (platformMatch) {
+    const plines = platformMatch[1].split("\n");
+    for (const line of plines) {
+      const itemMatch = line.match(/^\s+-\s*["']?([^"'\n]+)["']?\s*$/);
+      if (itemMatch) platforms.push(itemMatch[1].trim().toLowerCase());
+    }
+  }
+  if (platforms.length > 0) {
+    meta.platforms = platforms;
+  }
+
   return { meta, body };
 }
 
@@ -166,6 +175,7 @@ export function loadSkill(path: string): Skill | null {
       path,
       triggers,
       description: meta.description as string | undefined,
+      platforms: meta.platforms as string[] | undefined,
       content: body,
     };
   } catch {
@@ -222,17 +232,27 @@ export function discoverSkills(cwd: string, pluginRoot?: string): Skill[] {
 }
 
 /**
- * Find skills matching the prompt (supports typos via Levenshtein distance)
+ * Find skills matching the prompt (supports typos via Levenshtein distance).
+ *
+ * @param platform - If provided, skills with a `platforms` restriction are
+ *   only included when the current platform is listed. Skills without the
+ *   field are always eligible.
  */
 export function matchSkills(
   prompt: string,
   skills: Skill[],
   maxResults = 3,
+  platform?: string,
 ): Skill[] {
   const promptLower = prompt.toLowerCase();
   const matches: SkillMatchResult[] = [];
 
   for (const skill of skills) {
+    // Platform gate: skip skills restricted to a different platform
+    if (platform && skill.platforms && skill.platforms.length > 0) {
+      if (!skill.platforms.includes(platform)) continue;
+    }
+
     let score = 0;
 
     for (const trigger of skill.triggers) {

package/src/core/types.ts

@@ -67,6 +67,7 @@ export interface SessionInitResult {
     category: string;
     tags: string[];
   }>;
+  project_memory_overflow?: boolean;
   decisions: Array<{ topic: string; value: string; rationale?: string }>;
   recent_sessions: Array<{
     session_id: string;
@@ -83,6 +84,7 @@ export interface MemoryInjection {
   static: {
     global: string[];
     project: string[];
+    projectOverflow?: boolean;
     decisions: string[];
   };
   dynamic: {
@@ -109,6 +111,8 @@ export interface Skill {
   path: string;
   triggers: string[];
   description?: string;
+  /** Optional platform restriction. If set, only matched on listed platforms ("opencode", "claude-code"). */
+  platforms?: string[];
   content: string;
 }
 

package/src/opencode/hooks.ts

@@ -26,6 +26,7 @@
  */
 
 import { execFileSync } from "child_process";
+import { join } from "path";
 import { findAideBinary } from "../core/aide-client.js";
 import {
   ensureDirectories,
@@ -66,6 +67,7 @@ import {
   buildSummaryFromPartials,
   cleanupPartials,
 } from "../core/partial-memory.js";
+import { ContextPruningTracker } from "../core/context-pruning/index.js";
 import type { MemoryInjection, SessionState } from "../core/types.js";
 import type {
   Hooks,
@@ -114,6 +116,8 @@ interface AideState {
   /** Per-session metadata for agent-like tracking */
   sessionInfoMap: Map<string, SessionInfo>;
   client: OpenCodeClient;
+  /** Context pruning tracker for dedup/supersede/purge of tool outputs */
+  pruningTracker: ContextPruningTracker;
 }
 
 /**
@@ -142,6 +146,7 @@ export async function createHooks(
     lastUserPrompt: null,
     sessionInfoMap: new Map(),
     client,
+    pruningTracker: new ContextPruningTracker(cwd),
   };
 
   // Run one-time initialization (directories, binary, config)
@@ -184,16 +189,49 @@ function createConfigHandler(
       // Discover all skills and register them as OpenCode commands
       const skills = discoverSkills(state.cwd, state.pluginRoot ?? undefined);
 
+      // Register our skill directories with OpenCode's native skill discovery
+      // as a fallback, so the native `skill` tool can also find them.
+      const skillsConfig = (input as Record<string, unknown>).skills as
+        | { paths?: string[]; urls?: string[] }
+        | undefined;
+      const existingPaths = skillsConfig?.paths ?? [];
+      const aidePaths = [
+        join(state.cwd, ".aide", "skills"),
+        join(state.cwd, "skills"),
+      ];
+      if (state.pluginRoot) {
+        aidePaths.push(join(state.pluginRoot, "skills"));
+      }
+      // Only add paths that aren't already registered
+      const newPaths = aidePaths.filter((p) => !existingPaths.includes(p));
+      if (newPaths.length > 0) {
+        (input as Record<string, unknown>).skills = {
+          ...skillsConfig,
+          paths: [...existingPaths, ...newPaths],
+        };
+      }
+
       if (!input.command) {
         input.command = {};
       }
 
       for (const skill of skills) {
+        // Skip skills restricted to other platforms
+        if (
+          skill.platforms &&
+          skill.platforms.length > 0 &&
+          !skill.platforms.includes("opencode")
+        ) {
+          continue;
+        }
         const commandName = `aide:${skill.name}`;
         // Only register if not already defined (user config takes priority)
         if (!input.command[commandName]) {
           input.command[commandName] = {
-            template: `Activate the aide "${skill.name}" skill. {{arguments}}`,
+            // IMPORTANT: Template wording must NOT trigger the native "skill" tool.
+            // The actual instructions are injected into the system prompt by
+            // createCommandHandler → pendingSkillsContext → createSystemTransformHandler.
+            template: `Follow the aide "${skill.name}" instructions that have been injected into your system prompt. Do NOT use the skill tool. {{arguments}}`,
             description: skill.description || `aide ${skill.name} skill`,
           };
         }
@@ -234,9 +272,18 @@ function createCommandHandler(state: AideState): (
         // Format the skill content for injection
         const context = formatSkillsContext([skill]);
 
-        // Store for system transform injection
+        // Store for system transform injection (into system prompt)
         state.pendingSkillsContext = context;
 
+        // Also inject into the command output parts so the model sees the
+        // instructions directly in the user message. This avoids reliance
+        // on the system transform alone and prevents the model from trying
+        // to call the native "skill" tool to find the instructions.
+        output.parts.push({
+          type: "text",
+          text: `<aide-instructions>\n${context}\n</aide-instructions>`,
+        });
+
         // Also store the arguments as the user prompt for the transform
         if (args) {
           state.lastUserPrompt = args;
@@ -299,7 +346,7 @@ function initializeAide(state: AideState): void {
         state.binary,
         state.cwd,
         projectName,
-        3,
+        2,
         config,
       );
     }
@@ -506,14 +553,20 @@ async function handleSessionIdle(
     let summary: string | null = null;
 
     if (partials.length > 0) {
-      const commits = getSessionCommits(state.cwd);
+      const commits = getSessionCommits(
+        state.cwd,
+        state.sessionState?.startedAt,
+      );
       summary = buildSummaryFromPartials(partials, commits, []);
       debug(SOURCE, `Built summary from ${partials.length} partials`);
     }
 
     // Fall back to state-only summary if no partials
     if (!summary) {
-      summary = buildSessionSummaryFromState(state.cwd);
+      summary = buildSessionSummaryFromState(
+        state.cwd,
+        state.sessionState?.startedAt,
+      );
     }
 
     if (summary) {
@@ -584,7 +637,7 @@ async function handleMessagePartUpdated(
   state.lastUserPrompt = prompt;
 
   const skills = discoverSkills(state.cwd, state.pluginRoot ?? undefined);
-  const matched = matchSkills(prompt, skills, 3);
+  const matched = matchSkills(prompt, skills, 3, "opencode");
 
   if (matched.length > 0) {
     try {
@@ -704,6 +757,29 @@ function createToolAfterHandler(
       debug(SOURCE, `Partial memory write failed (non-fatal): ${err}`);
     }
 
+    // Context pruning: dedup/supersede/purge tool outputs
+    try {
+      const toolArgs = (_output.metadata?.args || {}) as Record<
+        string,
+        unknown
+      >;
+      const pruneResult = state.pruningTracker.process(
+        input.callID,
+        input.tool,
+        toolArgs,
+        _output.output,
+      );
+      if (pruneResult.modified) {
+        _output.output = pruneResult.output;
+        debug(
+          SOURCE,
+          `Context pruning [${pruneResult.strategy}]: saved ${pruneResult.bytesSaved} bytes for ${input.tool}`,
+        );
+      }
+    } catch (err) {
+      debug(SOURCE, `Context pruning failed (non-fatal): ${err}`);
+    }
+
     // Comment checker: detect excessive comments in Write/Edit output
     try {
       const toolArgs = (_output.metadata?.args || {}) as Record<
@@ -742,6 +818,10 @@ function createCompactionHandler(
   output: { context: string[]; prompt?: string },
 ) => Promise<void> {
   return async (input, output) => {
+    // Reset context pruning tracker — compaction clears the conversation
+    // history, so dedup/supersede references would be stale.
+    state.pruningTracker.reset();
+
     // Save state snapshot before compaction
     if (state.binary) {
       saveStateSnapshot(state.binary, state.cwd, input.sessionID);
@@ -758,7 +838,10 @@ function createCompactionHandler(
         let summary: string | null = null;
 
         if (partials.length > 0) {
-          const commits = getSessionCommits(state.cwd);
+          const commits = getSessionCommits(
+            state.cwd,
+            state.sessionState?.startedAt,
+          );
           summary = buildSummaryFromPartials(partials, commits, []);
           debug(
             SOURCE,
@@ -768,7 +851,10 @@ function createCompactionHandler(
 
         // Fall back to state-only summary if no partials
         if (!summary) {
-          summary = buildSessionSummaryFromState(state.cwd);
+          summary = buildSessionSummaryFromState(
+            state.cwd,
+            state.sessionState?.startedAt,
+          );
         }
 
         if (summary) {
@@ -802,7 +888,7 @@ function createCompactionHandler(
           state.binary,
           state.cwd,
           projectName,
-          3,
+          2,
         );
         state.memories = freshMemories;
         state.welcomeContext = buildWelcomeContext(
@@ -844,6 +930,17 @@ function createSystemTransformHandler(
       output.system.push(state.welcomeContext);
     }
 
+    // Inject context pruning notes only after the first prune fires.
+    // Avoids adding ~280 bytes to every session that never triggers pruning.
+    if (state.pruningTracker.getStats().prunedCalls > 0) {
+      output.system.push(`<aide-context-pruning>
+Tool outputs may contain these tags from aide's context optimization:
+- [aide:dedup] — This output is identical to a previous call. Refer to the earlier result.
+- [aide:supersede] — A prior Read of this file is now stale after a Write/Edit.
+- [aide:purge] — Large error output was trimmed. Re-run the command for full output.
+</aide-context-pruning>`);
+    }
+
     // Inject per-session context only when swarm mode is active and session
     // has been assigned a worktree/role (e.g., by swarm orchestration).
     // Without this guard, every normal session would incorrectly be told
@@ -894,7 +991,12 @@ function createSystemTransformHandler(
     } else if (state.lastUserPrompt) {
       try {
         const skills = discoverSkills(state.cwd, state.pluginRoot ?? undefined);
-        const matched = matchSkills(state.lastUserPrompt, skills, 3);
+        const matched = matchSkills(
+          state.lastUserPrompt,
+          skills,
+          3,
+          "opencode",
+        );
         if (matched.length > 0) {
           output.system.push(formatSkillsContext(matched));
           debug(
@@ -907,8 +1009,9 @@ function createSystemTransformHandler(
       }
     }
 
-    // Inject messaging protocol for multi-instance coordination
-    output.system.push(`<aide-messaging>
+    // Inject messaging protocol only in swarm mode (saves ~450 bytes per turn otherwise)
+    if (rawMode === "swarm") {
+      output.system.push(`<aide-messaging>
 
 ## Agent Messaging
 
@@ -927,6 +1030,7 @@ Use aide MCP tools to coordinate with other agents or sessions:
 - Check messages periodically for requests from other agents
 
 </aide-messaging>`);
+    }
   };
 }