@cortexkit/magic-context 0.16.3 → 0.17.0

package/dist/index.js

@@ -160419,18 +160419,77 @@ var init_tag_part_guards = __esm(() => {
   init_tag_content_primitives();
 });
 
+// ../plugin/src/shared/record-type-guard.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ../plugin/src/hooks/magic-context/tool-drop-target.ts
+function hasMeaningfulPart(part) {
+  if (!isRecord2(part))
+    return false;
+  const type = part.type;
+  if (type === "text") {
+    return typeof part.text === "string" && part.text.trim().length > 0;
+  }
+  if (typeof type !== "string")
+    return false;
+  if (IGNORE_PART_TYPES.has(type))
+    return false;
+  return true;
+}
+
+class ToolMutationBatch {
+  partsToRemove = new Set;
+  affectedMessages = new Set;
+  messages;
+  constructor(messages) {
+    this.messages = messages;
+  }
+  markForRemoval(occurrence) {
+    this.partsToRemove.add(occurrence.part);
+    this.affectedMessages.add(occurrence.message);
+  }
+  finalize() {
+    if (this.partsToRemove.size === 0)
+      return;
+    for (const message of this.affectedMessages) {
+      message.parts = message.parts.filter((p) => !this.partsToRemove.has(p));
+    }
+    for (let i = this.messages.length - 1;i >= 0; i -= 1) {
+      if (!this.messages[i].parts.some(hasMeaningfulPart)) {
+        this.messages.splice(i, 1);
+      }
+    }
+    this.partsToRemove.clear();
+    this.affectedMessages.clear();
+  }
+}
+var IGNORE_PART_TYPES;
+var init_tool_drop_target = __esm(() => {
+  IGNORE_PART_TYPES = new Set([
+    "thinking",
+    "reasoning",
+    "redacted_thinking",
+    "meta",
+    "step-start",
+    "step-finish"
+  ]);
+});
+
 // ../plugin/src/hooks/magic-context/read-session-chunk.ts
 var sessionProviders;
 var init_read_session_chunk = __esm(async () => {
   init_read_session_formatting();
   init_tag_part_guards();
+  init_tool_drop_target();
   init_read_session_formatting();
   await init_read_session_db();
   sessionProviders = new Map;
 });
 
 // ../plugin/src/features/magic-context/message-index.ts
-var lastIndexedStatements, insertMessageStatements, upsertIndexStatements, deleteFtsStatements, deleteIndexStatements, countIndexedMessageStatements;
+var lastIndexedStatements, insertMessageStatements, upsertIndexStatements, deleteFtsStatements, deleteIndexStatements, countIndexedMessageStatements, indexedMessageIdStatements;
 var init_message_index = __esm(async () => {
   init_compression_depth_storage();
   await init_read_session_chunk();
@@ -160440,6 +160499,7 @@ var init_message_index = __esm(async () => {
   deleteFtsStatements = new WeakMap;
   deleteIndexStatements = new WeakMap;
   countIndexedMessageStatements = new WeakMap;
+  indexedMessageIdStatements = new WeakMap;
 });
 
 // ../plugin/src/shared/error-message.ts
@@ -160461,22 +160521,51 @@ function getCurrentVersion(db) {
   const row = db.prepare("SELECT MAX(version) as version FROM schema_migrations").get();
   return row?.version ?? 0;
 }
+function isSiblingMigrationConflict(error48, version2) {
+  if (!(error48 instanceof Error))
+    return false;
+  const code = error48.code;
+  if (code !== "SQLITE_CONSTRAINT_PRIMARYKEY" && code !== "SQLITE_CONSTRAINT_UNIQUE") {
+    return false;
+  }
+  const msg = error48.message;
+  if (!msg.includes("schema_migrations"))
+    return false;
+  if (!msg.toLowerCase().includes("version"))
+    return false;
+  return true;
+}
 function runMigrations(db) {
   ensureMigrationsTable(db);
-  const currentVersion = getCurrentVersion(db);
-  const pendingMigrations = MIGRATIONS.filter((m) => m.version > currentVersion);
+  let currentVersion = getCurrentVersion(db);
+  let pendingMigrations = MIGRATIONS.filter((m) => m.version > currentVersion);
   if (pendingMigrations.length === 0) {
     return;
   }
   log2(`[migrations] current schema version: ${currentVersion}, applying ${pendingMigrations.length} migration(s)`);
-  for (const migration of pendingMigrations) {
+  let migrationIndex = 0;
+  while (migrationIndex < pendingMigrations.length) {
+    const migration = pendingMigrations[migrationIndex];
     try {
       db.transaction(() => {
         migration.up(db);
         db.prepare("INSERT INTO schema_migrations (version, description, applied_at) VALUES (?, ?, ?)").run(migration.version, migration.description, Date.now());
       })();
       log2(`[migrations] applied v${migration.version}: ${migration.description}`);
+      migrationIndex += 1;
     } catch (error48) {
+      if (isSiblingMigrationConflict(error48, migration.version)) {
+        log2(`[migrations] v${migration.version} already applied by sibling instance — resuming with re-read version`);
+        const reReadVersion = getCurrentVersion(db);
+        if (reReadVersion <= currentVersion) {
+          log2(`[migrations] FAILED v${migration.version}: sibling-conflict shape but version not advanced (${reReadVersion} <= ${currentVersion}) — failing closed`);
+          throw new Error(`Migration v${migration.version} failed: sibling conflict reported but version did not advance. Database may need manual repair.`);
+        }
+        currentVersion = reReadVersion;
+        pendingMigrations = MIGRATIONS.filter((m) => m.version > currentVersion);
+        migrationIndex = 0;
+        continue;
+      }
       log2(`[migrations] FAILED v${migration.version}: ${migration.description} — ${error48 instanceof Error ? error48.message : String(error48)}`);
       throw new Error(`Migration v${migration.version} failed: ${error48 instanceof Error ? error48.message : String(error48)}. Database may need manual repair.`);
     }
@@ -160688,30 +160777,361 @@ var init_migrations = __esm(async () => {
           db.exec("ALTER TABLE notes ADD COLUMN harness TEXT NOT NULL DEFAULT 'opencode'");
         }
       }
+    },
+    {
+      version: 8,
+      description: "Add partial indexes on tags(session_id, tag_number) for active and dropped",
+      up: (db) => {
+        db.exec(`
+                CREATE INDEX IF NOT EXISTS idx_tags_active_session_tag_number
+                ON tags(session_id, tag_number)
+                WHERE status = 'active';
+
+                CREATE INDEX IF NOT EXISTS idx_tags_dropped_session_tag_number
+                ON tags(session_id, tag_number)
+                WHERE status = 'dropped';
+            `);
+        db.exec("ANALYZE tags;");
+      }
+    },
+    {
+      version: 9,
+      description: "Persist tool_definition_measurements across plugin restarts",
+      up: (db) => {
+        db.exec(`
+                CREATE TABLE IF NOT EXISTS tool_definition_measurements (
+                    provider_id TEXT NOT NULL,
+                    model_id TEXT NOT NULL,
+                    agent_name TEXT NOT NULL,
+                    tool_id TEXT NOT NULL,
+                    token_count INTEGER NOT NULL,
+                    recorded_at INTEGER NOT NULL,
+                    PRIMARY KEY (provider_id, model_id, agent_name, tool_id)
+                );
+            `);
+      }
+    },
+    {
+      version: 10,
+      description: "Add tool_owner_message_id column to tags + composite identity indexes",
+      up: (db) => {
+        const cols = db.prepare("PRAGMA table_info(tags)").all();
+        if (!cols.some((c) => c.name === "tool_owner_message_id")) {
+          db.exec("ALTER TABLE tags ADD COLUMN tool_owner_message_id TEXT DEFAULT NULL");
+        }
+        db.exec(`
+                CREATE UNIQUE INDEX IF NOT EXISTS idx_tags_tool_composite
+                ON tags(session_id, message_id, tool_owner_message_id)
+                WHERE type = 'tool' AND tool_owner_message_id IS NOT NULL;
+
+                CREATE INDEX IF NOT EXISTS idx_tags_tool_null_owner
+                ON tags(session_id, message_id)
+                WHERE type = 'tool' AND tool_owner_message_id IS NULL;
+            `);
+      }
     }
   ];
 });
 
-// ../plugin/src/features/magic-context/storage-db.ts
-import { copyFileSync, cpSync, existsSync as existsSync16, mkdirSync as mkdirSync7 } from "node:fs";
+// ../plugin/src/features/magic-context/tool-definition-tokens.ts
+function keyFor(providerID, modelID, agentName) {
+  const agent = agentName && agentName.length > 0 ? agentName : "default";
+  return `${providerID}/${modelID}/${agent}`;
+}
+function setDatabase(db) {
+  persistenceDb = db;
+}
+function loadToolDefinitionMeasurements(db) {
+  let rows = [];
+  try {
+    rows = db.prepare("SELECT provider_id, model_id, agent_name, tool_id, token_count FROM tool_definition_measurements").all();
+  } catch {
+    return;
+  }
+  for (const row of rows) {
+    const key = keyFor(row.provider_id, row.model_id, row.agent_name);
+    let inner = measurements.get(key);
+    if (!inner) {
+      inner = new Map;
+      measurements.set(key, inner);
+    }
+    inner.set(row.tool_id, row.token_count);
+  }
+}
+var measurements, persistenceDb = null;
+var init_tool_definition_tokens = __esm(() => {
+  init_read_session_formatting();
+  measurements = new Map;
+});
+
+// ../plugin/src/features/magic-context/tool-owner-backfill.ts
+import { existsSync as existsSync16 } from "node:fs";
 import { join as join15 } from "node:path";
+function resolveOpencodeDbPath() {
+  return join15(getDataDir(), "opencode", "opencode.db");
+}
+function ensureBackfillStateTable(db) {
+  db.exec(`
+        CREATE TABLE IF NOT EXISTS tool_owner_backfill_state (
+            session_id TEXT PRIMARY KEY,
+            status TEXT NOT NULL CHECK (status IN ('pending', 'running', 'completed', 'skipped')),
+            started_at INTEGER,
+            lease_expires_at INTEGER,
+            completed_at INTEGER,
+            last_error TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_tool_owner_backfill_state_status
+        ON tool_owner_backfill_state(status);
+    `);
+}
+function runToolOwnerBackfill(db) {
+  const startedAt = performance.now();
+  ensureBackfillStateTable(db);
+  const result = {
+    sessionsProcessed: 0,
+    sessionsSkippedNoOcDb: 0,
+    sessionsSkippedNoMatches: 0,
+    sessionsCompleted: 0,
+    sessionsBlockedByLease: 0,
+    sessionsErrored: 0,
+    rowsUpdated: 0,
+    rowsLeftNull: 0,
+    durationMs: 0
+  };
+  if (!isToolOwnerBackfillNeeded(db)) {
+    result.durationMs = performance.now() - startedAt;
+    return result;
+  }
+  const opencodeDbPath = resolveOpencodeDbPath();
+  if (!existsSync16(opencodeDbPath)) {
+    log2(`[backfill] OpenCode DB not found at ${opencodeDbPath} — marking all unbackfilled sessions as skipped. Lazy adoption (defense-in-depth) handles legacy rows at runtime.`);
+    markAllUnbackfilledSessionsSkipped(db);
+    result.sessionsSkippedNoOcDb = countSessionsByStatus(db, "skipped");
+    result.durationMs = performance.now() - startedAt;
+    return result;
+  }
+  db.exec(`ATTACH '${opencodeDbPath}' AS oc_backfill`);
+  try {
+    backfillToolOwnersInChunks(db, result);
+  } finally {
+    try {
+      db.exec("DETACH DATABASE oc_backfill");
+    } catch (error48) {
+      log2(`[backfill] failed to detach oc_backfill database: ${error48 instanceof Error ? error48.message : String(error48)}`);
+    }
+  }
+  result.durationMs = performance.now() - startedAt;
+  log2(`[backfill] sessions=${result.sessionsProcessed} completed=${result.sessionsCompleted} skipped_no_oc=${result.sessionsSkippedNoOcDb} skipped_no_matches=${result.sessionsSkippedNoMatches} blocked_by_lease=${result.sessionsBlockedByLease} errored=${result.sessionsErrored} rows_updated=${result.rowsUpdated} rows_left_null=${result.rowsLeftNull} duration_ms=${Math.round(result.durationMs)}`);
+  return result;
+}
+function isToolOwnerBackfillNeeded(db) {
+  ensureBackfillStateTable(db);
+  const row = db.prepare(`SELECT 1 AS hit
+             FROM tags
+             WHERE type = 'tool' AND tool_owner_message_id IS NULL
+               AND NOT EXISTS (
+                   SELECT 1 FROM tool_owner_backfill_state s
+                   WHERE s.session_id = tags.session_id
+                     AND s.status IN ('completed', 'skipped')
+               )
+             LIMIT 1`).get();
+  return row !== null && row !== undefined;
+}
+function markAllUnbackfilledSessionsSkipped(db) {
+  const now = Date.now();
+  db.prepare(`INSERT INTO tool_owner_backfill_state(session_id, status, started_at, completed_at, last_error)
+         SELECT DISTINCT session_id, 'skipped', NULL, ?, NULL
+         FROM tags
+         WHERE type = 'tool' AND tool_owner_message_id IS NULL
+         ON CONFLICT(session_id) DO UPDATE SET
+             status = 'skipped',
+             completed_at = excluded.completed_at,
+             last_error = NULL
+         WHERE tool_owner_backfill_state.status NOT IN ('completed', 'running')`).run(now);
+}
+function countSessionsByStatus(db, status) {
+  const row = db.prepare("SELECT COUNT(*) AS c FROM tool_owner_backfill_state WHERE status = ?").get(status);
+  return row.c;
+}
+function acquireSessionLease(db, sessionId, now) {
+  const expiresAt = now + LEASE_DURATION_MS;
+  const result = db.prepare(`INSERT INTO tool_owner_backfill_state(session_id, status, started_at, lease_expires_at)
+             VALUES (?, 'running', ?, ?)
+             ON CONFLICT(session_id) DO UPDATE SET
+                 status = 'running',
+                 started_at = excluded.started_at,
+                 lease_expires_at = excluded.lease_expires_at,
+                 last_error = NULL
+             WHERE tool_owner_backfill_state.status IN ('pending', 'skipped')
+                OR (tool_owner_backfill_state.status = 'running'
+                    AND tool_owner_backfill_state.lease_expires_at < ?)`).run(sessionId, now, expiresAt, now);
+  return (result.changes ?? 0) === 1;
+}
+function renewSessionLease(db, sessionId, now) {
+  const expiresAt = now + LEASE_DURATION_MS;
+  db.prepare(`UPDATE tool_owner_backfill_state
+         SET lease_expires_at = ?
+         WHERE session_id = ? AND status = 'running'`).run(expiresAt, sessionId);
+}
+function markSessionCompleted(db, sessionId, now) {
+  db.prepare(`UPDATE tool_owner_backfill_state
+         SET status = 'completed', completed_at = ?, lease_expires_at = NULL, last_error = NULL
+         WHERE session_id = ?`).run(now, sessionId);
+}
+function markSessionSkipped(db, sessionId, now, reason) {
+  db.prepare(`INSERT INTO tool_owner_backfill_state(session_id, status, completed_at, last_error)
+         VALUES (?, 'skipped', ?, ?)
+         ON CONFLICT(session_id) DO UPDATE SET
+             status = 'skipped',
+             completed_at = excluded.completed_at,
+             last_error = excluded.last_error,
+             lease_expires_at = NULL`).run(sessionId, now, reason);
+}
+function markSessionErrored(db, sessionId, error48) {
+  const message = error48 instanceof Error ? error48.message : String(error48);
+  db.prepare(`UPDATE tool_owner_backfill_state
+         SET last_error = ?, lease_expires_at = NULL
+         WHERE session_id = ?`).run(message, sessionId);
+}
+function getSessionsNeedingBackfill(db) {
+  const rows = db.prepare(`SELECT DISTINCT t.session_id
+             FROM tags t
+             LEFT JOIN tool_owner_backfill_state s ON s.session_id = t.session_id
+             WHERE t.type = 'tool' AND t.tool_owner_message_id IS NULL
+               AND (s.status IS NULL OR s.status NOT IN ('completed', 'skipped'))
+             ORDER BY t.session_id ASC`).all();
+  return rows.map((r) => r.session_id);
+}
+function buildSessionOwnerMap(db, sessionId) {
+  const rows = db.prepare(`SELECT
+                COALESCE(
+                    CASE WHEN json_extract(p.data, '$.type') = 'tool_use'
+                        THEN json_extract(p.data, '$.id')
+                    END,
+                    json_extract(p.data, '$.callID')
+                ) AS callid,
+                m.id AS owner_id,
+                m.time_created AS owner_t_created,
+                p.id AS part_id,
+                p.time_created AS part_t_created
+             FROM oc_backfill.message m
+             INNER JOIN oc_backfill.part p ON p.message_id = m.id
+             WHERE m.session_id = ?
+               AND json_extract(m.data, '$.role') = 'assistant'
+               AND (
+                   (json_extract(p.data, '$.type') IN ('tool', 'tool-invocation')
+                       AND json_extract(p.data, '$.callID') IS NOT NULL)
+                   OR (json_extract(p.data, '$.type') = 'tool_use'
+                       AND json_extract(p.data, '$.id') IS NOT NULL)
+               )
+             ORDER BY
+                 m.time_created ASC,
+                 m.id ASC,
+                 p.time_created ASC,
+                 p.id ASC`).all(sessionId);
+  const oldestByCallId = new Map;
+  for (const r of rows) {
+    if (typeof r.callid !== "string" || r.callid.length === 0)
+      continue;
+    if (!oldestByCallId.has(r.callid)) {
+      oldestByCallId.set(r.callid, r.owner_id);
+    }
+  }
+  return oldestByCallId;
+}
+function applyOwnersForSession(db, sessionId, ownersByCallId) {
+  if (ownersByCallId.size === 0) {
+    const leftNull = db.prepare(`SELECT COUNT(*) AS c FROM tags
+                     WHERE session_id = ? AND type = 'tool'
+                       AND tool_owner_message_id IS NULL`).get(sessionId).c;
+    return { rowsUpdated: 0, rowsLeftNull: leftNull };
+  }
+  const findOrphanStmt = db.prepare(`SELECT id FROM tags
+         WHERE session_id = ? AND message_id = ? AND type = 'tool'
+           AND tool_owner_message_id IS NULL
+         ORDER BY tag_number ASC
+         LIMIT 1`);
+  const updateRowStmt = db.prepare(`UPDATE tags
+         SET tool_owner_message_id = ?
+         WHERE id = ? AND tool_owner_message_id IS NULL`);
+  let rowsUpdated = 0;
+  db.transaction(() => {
+    for (const [callId, ownerId] of ownersByCallId) {
+      const orphan = findOrphanStmt.get(sessionId, callId);
+      if (!orphan)
+        continue;
+      const result = updateRowStmt.run(ownerId, orphan.id);
+      rowsUpdated += result.changes ?? 0;
+    }
+  })();
+  const rowsLeftNull = db.prepare(`SELECT COUNT(*) AS c FROM tags
+                 WHERE session_id = ? AND type = 'tool'
+                   AND tool_owner_message_id IS NULL`).get(sessionId).c;
+  return { rowsUpdated, rowsLeftNull };
+}
+function backfillToolOwnersInChunks(db, result) {
+  const sessionIds = getSessionsNeedingBackfill(db);
+  let lastRenewedAt = Date.now();
+  for (const sessionId of sessionIds) {
+    const now = Date.now();
+    result.sessionsProcessed += 1;
+    const acquired = acquireSessionLease(db, sessionId, now);
+    if (!acquired) {
+      result.sessionsBlockedByLease += 1;
+      continue;
+    }
+    try {
+      const owners = buildSessionOwnerMap(db, sessionId);
+      const { rowsUpdated, rowsLeftNull } = applyOwnersForSession(db, sessionId, owners);
+      result.rowsUpdated += rowsUpdated;
+      result.rowsLeftNull += rowsLeftNull;
+      if (owners.size === 0) {
+        markSessionSkipped(db, sessionId, Date.now(), "no_oc_matches");
+        result.sessionsSkippedNoMatches += 1;
+      } else {
+        markSessionCompleted(db, sessionId, Date.now());
+        result.sessionsCompleted += 1;
+      }
+    } catch (error48) {
+      log2(`[backfill] session=${sessionId} errored: ${error48 instanceof Error ? error48.message : String(error48)}`);
+      markSessionErrored(db, sessionId, error48);
+      result.sessionsErrored += 1;
+    }
+    const sinceRenew = Date.now() - lastRenewedAt;
+    if (sinceRenew > LEASE_RENEWAL_MS) {
+      renewSessionLease(db, sessionId, Date.now());
+      lastRenewedAt = Date.now();
+    }
+  }
+}
+var LEASE_DURATION_MS, LEASE_RENEWAL_MS;
+var init_tool_owner_backfill = __esm(() => {
+  init_data_path();
+  init_logger();
+  LEASE_DURATION_MS = 5 * 60 * 1000;
+  LEASE_RENEWAL_MS = 60 * 1000;
+});
+
+// ../plugin/src/features/magic-context/storage-db.ts
+import { copyFileSync, cpSync, existsSync as existsSync17, mkdirSync as mkdirSync7 } from "node:fs";
+import { join as join16 } from "node:path";
 function resolveDatabasePath() {
   const dbDir = getMagicContextStorageDir();
-  return { dbDir, dbPath: join15(dbDir, "context.db") };
+  return { dbDir, dbPath: join16(dbDir, "context.db") };
 }
 function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
-  if (existsSync16(targetDbPath))
+  if (existsSync17(targetDbPath))
     return;
   const legacyDir = getLegacyOpenCodeMagicContextStorageDir();
-  const legacyDbPath = join15(legacyDir, "context.db");
-  if (!existsSync16(legacyDbPath))
+  const legacyDbPath = join16(legacyDir, "context.db");
+  if (!existsSync17(legacyDbPath))
     return;
   log2(`[magic-context] migrating legacy plugin storage: ${legacyDir} -> ${targetDbDir} (legacy left in place as backup)`);
   mkdirSync7(targetDbDir, { recursive: true });
   for (const suffix of ["", "-wal", "-shm"]) {
     const src = `${legacyDbPath}${suffix}`;
-    const dst = join15(targetDbDir, `context.db${suffix}`);
-    if (existsSync16(src)) {
+    const dst = join16(targetDbDir, `context.db${suffix}`);
+    if (existsSync17(src)) {
       try {
         copyFileSync(src, dst);
       } catch (error48) {
@@ -160719,9 +161139,9 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
       }
     }
   }
-  const legacyModelsDir = join15(legacyDir, "models");
-  const targetModelsDir = join15(targetDbDir, "models");
-  if (existsSync16(legacyModelsDir) && !existsSync16(targetModelsDir)) {
+  const legacyModelsDir = join16(legacyDir, "models");
+  const targetModelsDir = join16(targetDbDir, "models");
+  if (existsSync17(legacyModelsDir) && !existsSync17(targetModelsDir)) {
     try {
       cpSync(legacyModelsDir, targetModelsDir, { recursive: true });
     } catch (error48) {
@@ -161007,6 +161427,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "tags", "tool_name", "TEXT");
   ensureColumn(db, "tags", "input_byte_size", "INTEGER DEFAULT 0");
   ensureColumn(db, "tags", "caveman_depth", "INTEGER DEFAULT 0");
+  ensureColumn(db, "tags", "tool_owner_message_id", "TEXT DEFAULT NULL");
   ensureColumn(db, "session_meta", "system_prompt_tokens", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "compaction_marker_state", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "key_files", "TEXT DEFAULT ''");
@@ -161105,6 +161526,13 @@ function openDatabase() {
     const db = new Database(dbPath);
     initializeDatabase(db);
     runMigrations(db);
+    try {
+      runToolOwnerBackfill(db);
+    } catch (error48) {
+      log2(`[magic-context] tool-owner backfill failed (continuing with lazy adoption fallback): ${getErrorMessage(error48)}`);
+    }
+    setDatabase(db);
+    loadToolDefinitionMeasurements(db);
     databases.set(dbPath, db);
     persistenceByDatabase.set(db, true);
     persistenceErrorByDatabase.delete(db);
@@ -161133,6 +161561,8 @@ var databases, persistenceByDatabase, persistenceErrorByDatabase;
 var init_storage_db = __esm(async () => {
   init_data_path();
   init_logger();
+  init_tool_definition_tokens();
+  init_tool_owner_backfill();
   await __promiseAll([
     init_sqlite(),
     init_migrations()
@@ -161197,7 +161627,7 @@ var init_storage_ops = __esm(() => {
 var init_storage_source = () => {};
 
 // ../plugin/src/features/magic-context/storage-tags.ts
-var insertTagStatements, updateTagStatusStatements, updateTagDropModeStatements, updateTagMessageIdStatements, getTagNumbersByMessageIdStatements, deleteTagsByMessageIdStatements, getMaxTagNumberBySessionStatements, getTagNumberByMessageIdStatements, updateTagByteSizeStatements, updateTagInputByteSizeStatements;
+var insertTagStatements, updateTagStatusStatements, updateTagDropModeStatements, updateTagMessageIdStatements, getTagNumbersByMessageIdStatements, deleteTagsByMessageIdStatements, getMaxTagNumberBySessionStatements, getTagNumberByMessageIdStatements, updateTagByteSizeStatements, updateTagInputByteSizeStatements, getOwnerScopedToolTagNumbersStatements, getActiveTagsBySessionStatements, getMaxDroppedTagNumberStatements, getToolTagNumberByOwnerStatements, getNullOwnerToolTagStatements, adoptNullOwnerToolTagStatements, deleteToolTagsByOwnerStatements;
 var init_storage_tags = __esm(() => {
   insertTagStatements = new WeakMap;
   updateTagStatusStatements = new WeakMap;
@@ -161209,6 +161639,13 @@ var init_storage_tags = __esm(() => {
   getTagNumberByMessageIdStatements = new WeakMap;
   updateTagByteSizeStatements = new WeakMap;
   updateTagInputByteSizeStatements = new WeakMap;
+  getOwnerScopedToolTagNumbersStatements = new WeakMap;
+  getActiveTagsBySessionStatements = new WeakMap;
+  getMaxDroppedTagNumberStatements = new WeakMap;
+  getToolTagNumberByOwnerStatements = new WeakMap;
+  getNullOwnerToolTagStatements = new WeakMap;
+  adoptNullOwnerToolTagStatements = new WeakMap;
+  deleteToolTagsByOwnerStatements = new WeakMap;
 });
 
 // ../plugin/src/features/magic-context/storage.ts
@@ -161227,20 +161664,20 @@ var init_storage = __esm(async () => {
 });
 
 // ../pi-plugin/src/config/index.ts
-import { existsSync as existsSync17, readFileSync as readFileSync12 } from "node:fs";
+import { existsSync as existsSync18, readFileSync as readFileSync12 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 function getProjectConfigPaths(cwd) {
-  const basePath = join16(cwd, ".pi", CONFIG_FILE_NAME);
+  const basePath = join17(cwd, ".pi", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function getUserConfigPaths() {
   const home = process.env.HOME ?? homedir11();
-  const basePath = join16(home, ".pi", "agent", CONFIG_FILE_NAME);
+  const basePath = join17(home, ".pi", "agent", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function resolveFirstExisting(paths) {
-  return paths.find((path4) => existsSync17(path4));
+  return paths.find((path4) => existsSync18(path4));
 }
 function loadConfigFile2(path4, scope) {
   try {
@@ -161374,10 +161811,10 @@ var init_config2 = __esm(() => {
 
 // src/lib/diagnostics-pi.ts
 import { createHash } from "node:crypto";
-import { existsSync as existsSync18, readFileSync as readFileSync13, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync13, statSync as statSync4 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
 import { homedir as homedir12, tmpdir as tmpdir5, userInfo as userInfo3 } from "node:os";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 function getSelfVersion3() {
   const req = createRequire5(import.meta.url);
   for (const relPath of ["../../package.json", "../package.json"]) {
@@ -161392,7 +161829,7 @@ function getSelfVersion3() {
 }
 function fileSize2(path4) {
   try {
-    return existsSync18(path4) ? statSync4(path4).size : 0;
+    return existsSync19(path4) ? statSync4(path4).size : 0;
   } catch {
     return 0;
   }
@@ -161442,7 +161879,7 @@ function sanitizeValue2(value, key = "") {
   return value;
 }
 function readJsonc3(path4) {
-  if (!existsSync18(path4))
+  if (!existsSync19(path4))
     return { value: {} };
   try {
     return {
@@ -161456,13 +161893,13 @@ function readJsonc3(path4) {
   }
 }
 function getProjectConfigPath(cwd) {
-  return join17(cwd, ".pi", "magic-context.jsonc");
+  return join18(cwd, ".pi", "magic-context.jsonc");
 }
 function readConfigDiagnostic(path4) {
   const parsed = readJsonc3(path4);
   return {
     path: path4,
-    exists: existsSync18(path4),
+    exists: existsSync19(path4),
     ...parsed.parseError ? { parseError: parsed.parseError } : {},
     flags: sanitizeValue2(parsed.value)
   };
@@ -161482,9 +161919,9 @@ async function collectDiagnostics2(cwd = process.cwd()) {
   const projectConfigPath = getProjectConfigPath(cwd);
   const loaded = loadPiConfig({ cwd });
   const storageDirPath = getMagicContextStorageDir();
-  const dbPath = join17(storageDirPath, "context.db");
-  const logPath = join17(tmpdir5(), "magic-context.log");
-  const logFileSize = existsSync18(logPath) ? statSync4(logPath).size : 0;
+  const dbPath = join18(storageDirPath, "context.db");
+  const logPath = join18(tmpdir5(), "magic-context.log");
+  const logFileSize = existsSync19(logPath) ? statSync4(logPath).size : 0;
   const otherPiExtensions = packages.filter((entry) => !hasMagicContextPackage([entry]));
   return {
     timestamp: new Date().toISOString(),
@@ -161497,7 +161934,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     piVersion: pi ? getPiVersion(pi.path) : null,
     settings: {
       path: settingsPath,
-      exists: existsSync18(settingsPath),
+      exists: existsSync19(settingsPath),
       ...settingsParsed.parseError ? { parseError: settingsParsed.parseError } : {},
       hasMagicContextPackage: hasMagicContextPackage(packages),
       packages: packages.map(sanitizeString2)
@@ -161513,7 +161950,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     loadWarnings: loaded.warnings.map(sanitizeString2),
     storageDir: {
       path: storageDirPath,
-      exists: existsSync18(storageDirPath),
+      exists: existsSync19(storageDirPath),
       contextDbSizeBytes: fileSize2(dbPath)
     },
     conflicts: {
@@ -161522,7 +161959,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     },
     logFile: {
       path: logPath,
-      exists: existsSync18(logPath),
+      exists: existsSync19(logPath),
       sizeKb: Math.round(logFileSize / 1024)
     }
   };
@@ -161612,7 +162049,7 @@ var init_diagnostics_pi = __esm(() => {
 
 // src/lib/logs-pi.ts
 import { readFileSync as readFileSync14, writeFileSync as writeFileSync11 } from "node:fs";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 function sanitizeLogContent2(content) {
   return sanitizeString2(content);
 }
@@ -161656,7 +162093,7 @@ async function bundleIssueReport2(report, description, title, options = {}) {
   ].join(`
 `);
   const cwd = options.cwd ?? process.cwd();
-  const path4 = join18(cwd, `magic-context-pi-issue-${formatTimestamp2(options.now ?? new Date)}.md`);
+  const path4 = join19(cwd, `magic-context-pi-issue-${formatTimestamp2(options.now ?? new Date)}.md`);
   writeFileSync11(path4, `${bodyMarkdown}
 `);
   return { path: path4, bodyMarkdown };
@@ -161668,7 +162105,7 @@ var init_logs_pi = __esm(() => {
 // src/commands/doctor-pi.ts
 import { execFileSync as execFileSync3, spawnSync as spawnSync3 } from "node:child_process";
 import {
-  existsSync as existsSync19,
+  existsSync as existsSync20,
   mkdirSync as mkdirSync8,
   readdirSync as readdirSync4,
   readFileSync as readFileSync15,
@@ -161678,7 +162115,7 @@ import {
 } from "node:fs";
 import { createRequire as createRequire6 } from "node:module";
 import { homedir as homedir13, tmpdir as tmpdir6 } from "node:os";
-import { dirname as dirname9, join as join19 } from "node:path";
+import { dirname as dirname9, join as join20 } from "node:path";
 function depsFrom(options) {
   return {
     ...DEFAULT_DEPS,
@@ -161781,10 +162218,10 @@ function hasPiPackage(packages) {
   return packages.some((entry) => entry === PI_PACKAGE_SOURCE || entry === PACKAGE_NAME2 || entry.includes("pi-magic-context"));
 }
 function projectConfigPath(cwd) {
-  return join19(cwd, ".pi", "magic-context.jsonc");
+  return join20(cwd, ".pi", "magic-context.jsonc");
 }
 function readConfigForEmbedding(path4) {
-  if (!existsSync19(path4))
+  if (!existsSync20(path4))
     return null;
   try {
     const rawText = readFileSync15(path4, "utf-8");
@@ -161846,19 +162283,19 @@ function countTable(db, table) {
 }
 function cacheRoots() {
   const home = homedir13();
-  const cacheHome = process.env.XDG_CACHE_HOME || join19(home, ".cache");
+  const cacheHome = process.env.XDG_CACHE_HOME || join20(home, ".cache");
   return [
-    join19(home, ".pi", "cache", "extensions"),
-    join19(home, ".pi", "cache", "packages"),
-    join19(cacheHome, "pi", "extensions"),
-    join19(cacheHome, "pi", "packages"),
-    join19(getPiAgentConfigDir(), "cache", "extensions")
+    join20(home, ".pi", "cache", "extensions"),
+    join20(home, ".pi", "cache", "packages"),
+    join20(cacheHome, "pi", "extensions"),
+    join20(cacheHome, "pi", "packages"),
+    join20(getPiAgentConfigDir(), "cache", "extensions")
   ];
 }
 function findPiMagicContextCacheDirs(self, force = false) {
   const found = new Map;
   const visit = (path4, depth) => {
-    if (depth < 0 || !existsSync19(path4))
+    if (depth < 0 || !existsSync20(path4))
       return;
     let stat;
     try {
@@ -161868,8 +162305,8 @@ function findPiMagicContextCacheDirs(self, force = false) {
     }
     if (!stat.isDirectory())
       return;
-    const packageJson = join19(path4, "package.json");
-    if (existsSync19(packageJson)) {
+    const packageJson = join20(path4, "package.json");
+    if (existsSync20(packageJson)) {
       try {
         const pkg = JSON.parse(readFileSync15(packageJson, "utf-8"));
         const name2 = typeof pkg.name === "string" ? pkg.name : "";
@@ -161890,7 +162327,7 @@ function findPiMagicContextCacheDirs(self, force = false) {
       return;
     }
     for (const entry of entries)
-      visit(join19(path4, entry), depth - 1);
+      visit(join20(path4, entry), depth - 1);
   };
   for (const root of cacheRoots())
     visit(root, 5);
@@ -161927,7 +162364,7 @@ async function runHealthChecks(options) {
   }
   const settingsPath = getPiUserExtensionsPath();
   let packages = [];
-  if (!existsSync19(settingsPath)) {
+  if (!existsSync20(settingsPath)) {
     add(results, "warn", `Pi settings not found at ${settingsPath}`);
     repairPlan.addPackageEntry = true;
   } else {
@@ -161951,7 +162388,7 @@ async function runHealthChecks(options) {
     ["user", userConfigPath, true],
     ["project", projectPath, false]
   ]) {
-    if (!existsSync19(path4)) {
+    if (!existsSync20(path4)) {
       if (required2) {
         add(results, "warn", `No ${label} magic-context.jsonc found at ${path4}`);
         repairPlan.writeUserConfig = true;
@@ -161984,8 +162421,8 @@ async function runHealthChecks(options) {
     add(results, "pass", `historian.model "${historianModel}" has thinking_level "${historianThinkingLevel}" configured`);
   }
   const storageDir = getMagicContextStorageDir();
-  const dbPath = join19(storageDir, "context.db");
-  const existedBeforeOpen = existsSync19(dbPath);
+  const dbPath = join20(storageDir, "context.db");
+  const existedBeforeOpen = existsSync20(dbPath);
   if (existedBeforeOpen)
     add(results, "pass", `Shared context DB exists at ${dbPath}`);
   else
@@ -162061,8 +162498,8 @@ async function runHealthChecks(options) {
   } else {
     add(results, "pass", "Pi extension cache clean (no stale cached package found)");
   }
-  const logPath = join19(tmpdir6(), "magic-context.log");
-  if (existsSync19(logPath)) {
+  const logPath = join20(tmpdir6(), "magic-context.log");
+  if (existsSync20(logPath)) {
     const stat = statSync5(logPath);
     const sizeKb = (stat.size / 1024).toFixed(0);
     const lines = readFileSync15(logPath, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
@@ -162071,10 +162508,10 @@ async function runHealthChecks(options) {
   } else {
     add(results, "info", `No plugin log file yet at ${logPath}`);
   }
-  const historianDumpDir = join19(tmpdir6(), "magic-context-historian");
-  if (existsSync19(historianDumpDir)) {
+  const historianDumpDir = join20(tmpdir6(), "magic-context-historian");
+  if (existsSync20(historianDumpDir)) {
     try {
-      const dumps = readdirSync4(historianDumpDir).filter((f) => f.endsWith(".xml")).map((f) => ({ name: f, mtime: statSync5(join19(historianDumpDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+      const dumps = readdirSync4(historianDumpDir).filter((f) => f.endsWith(".xml")).map((f) => ({ name: f, mtime: statSync5(join20(historianDumpDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
       if (dumps.length > 0) {
         add(results, "warn", `Historian debug dumps: ${dumps.length} file(s) in ${historianDumpDir}`);
         for (const dump of dumps.slice(0, 3)) {
@@ -162117,7 +162554,7 @@ function repair(plan, prompts) {
   }
   if (plan.writeUserConfig) {
     const configPath = getPiUserConfigPath();
-    if (!existsSync19(configPath)) {
+    if (!existsSync20(configPath)) {
       try {
         writeDefaultMagicContextConfig(configPath);
         prompts.log.success(`Wrote default Magic Context config to ${configPath}`);
@@ -162278,7 +162715,7 @@ var exports_doctor = {};
 __export(exports_doctor, {
   runDoctor: () => runDoctor3
 });
-import { existsSync as existsSync20, rmSync as rmSync3 } from "node:fs";
+import { existsSync as existsSync21, rmSync as rmSync3 } from "node:fs";
 async function runDoctor3(options) {
   if (options.clear)
     return runClear();
@@ -162362,7 +162799,7 @@ async function runClear() {
     const s = spinner();
     s.start(`Clearing ${item.path}`);
     try {
-      if (existsSync20(item.path)) {
+      if (existsSync21(item.path)) {
         rmSync3(item.path, { recursive: true, force: true });
       }
       s.stop(`Cleared ${item.path}`);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cortexkit/magic-context",
-	"version": "0.16.3",
+	"version": "0.17.0",
 	"description": "Unified CLI for Magic Context — setup, doctor, and migration across OpenCode and Pi",
 	"keywords": [
 		"opencode",