@hienlh/ppm 0.10.4 → 0.11.0

package/src/services/jira-watcher-db.service.ts

@@ -0,0 +1,195 @@
+import { getDb } from "./db.service.ts";
+import type {
+  JiraWatcherRow, JiraWatchResultRow,
+  JiraWatcher, JiraWatchResult, JiraWatcherMode, JiraResultStatus,
+} from "../types/jira.ts";
+
+// ── Row → API mappers ─────────────────────────────────────────────────
+
+export function rowToWatcher(row: JiraWatcherRow): JiraWatcher {
+  return {
+    id: row.id,
+    jiraConfigId: row.jira_config_id,
+    name: row.name,
+    jql: row.jql,
+    promptTemplate: row.prompt_template,
+    enabled: row.enabled === 1,
+    mode: row.mode as JiraWatcherMode,
+    intervalMs: row.interval_ms,
+    lastPolledAt: row.last_polled_at,
+    createdAt: row.created_at,
+  };
+}
+
+export function rowToResult(row: JiraWatchResultRow): JiraWatchResult {
+  return {
+    id: row.id,
+    watcherId: row.watcher_id,
+    issueKey: row.issue_key,
+    issueSummary: row.issue_summary,
+    issueUpdated: row.issue_updated,
+    sessionId: row.session_id,
+    status: row.status,
+    aiSummary: row.ai_summary,
+    source: row.source,
+    readAt: row.read_at,
+    triggeredBy: row.triggered_by,
+    createdAt: row.created_at,
+  };
+}
+
+// ── Watcher CRUD ──────────────────────────────────────────────────────
+
+export function createWatcher(
+  configId: number, name: string, jql: string,
+  opts?: { promptTemplate?: string; intervalMs?: number; mode?: JiraWatcherMode },
+): JiraWatcher {
+  const result = getDb().query(`
+    INSERT INTO jira_watchers (jira_config_id, name, jql, prompt_template, interval_ms, mode)
+    VALUES (?, ?, ?, ?, ?, ?) RETURNING *
+  `).get(
+    configId, name, jql,
+    opts?.promptTemplate ?? null,
+    opts?.intervalMs ?? 120000,
+    opts?.mode ?? "debug",
+  ) as JiraWatcherRow;
+  return rowToWatcher(result);
+}
+
+export function updateWatcher(
+  id: number,
+  fields: Partial<{ name: string; jql: string; promptTemplate: string | null; intervalMs: number; enabled: boolean; mode: JiraWatcherMode }>,
+): JiraWatcher | null {
+  const sets: string[] = [];
+  const params: (string | number | null)[] = [];
+  if (fields.name !== undefined) { sets.push("name = ?"); params.push(fields.name); }
+  if (fields.jql !== undefined) { sets.push("jql = ?"); params.push(fields.jql); }
+  if (fields.promptTemplate !== undefined) { sets.push("prompt_template = ?"); params.push(fields.promptTemplate); }
+  if (fields.intervalMs !== undefined) { sets.push("interval_ms = ?"); params.push(fields.intervalMs); }
+  if (fields.enabled !== undefined) { sets.push("enabled = ?"); params.push(fields.enabled ? 1 : 0); }
+  if (fields.mode !== undefined) { sets.push("mode = ?"); params.push(fields.mode); }
+  if (sets.length === 0) return getWatcherById(id);
+  params.push(id);
+  getDb().query(`UPDATE jira_watchers SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+  return getWatcherById(id);
+}
+
+export function deleteWatcher(id: number): boolean {
+  return getDb().query("DELETE FROM jira_watchers WHERE id = ?").run(id).changes > 0;
+}
+
+export function getWatcherById(id: number): JiraWatcher | null {
+  const row = getDb().query("SELECT * FROM jira_watchers WHERE id = ?").get(id) as JiraWatcherRow | null;
+  return row ? rowToWatcher(row) : null;
+}
+
+export function getWatchersByConfigId(configId: number): JiraWatcher[] {
+  const rows = getDb().query("SELECT * FROM jira_watchers WHERE jira_config_id = ? ORDER BY id")
+    .all(configId) as JiraWatcherRow[];
+  return rows.map(rowToWatcher);
+}
+
+export function getAllEnabledWatchers(): JiraWatcherRow[] {
+  return getDb().query("SELECT * FROM jira_watchers WHERE enabled = 1")
+    .all() as JiraWatcherRow[];
+}
+
+// ── Result CRUD ───────────────────────────────────────────────────────
+
+/** Insert a result. Resurrects soft-deleted duplicates. Returns true if row was inserted or resurrected. */
+export function insertResult(
+  watcherId: number | null, issueKey: string,
+  issueSummary: string | null, issueUpdated: string | null,
+  source: "watcher" | "manual" = "watcher",
+  triggeredBy: "auto" | "manual" = "auto",
+): { inserted: boolean; resultId: number | null } {
+  try {
+    const row = getDb().query(`
+      INSERT INTO jira_watch_results (watcher_id, issue_key, issue_summary, issue_updated, source, triggered_by)
+      VALUES (?, ?, ?, ?, ?, ?) RETURNING id
+    `).get(watcherId, issueKey, issueSummary, issueUpdated, source, triggeredBy) as { id: number } | null;
+    return { inserted: true, resultId: row?.id ?? null };
+  } catch (e: any) {
+    if (e.message?.includes("UNIQUE constraint")) {
+      // Resurrect soft-deleted row if it exists
+      const resurrected = getDb().query(`
+        UPDATE jira_watch_results
+        SET deleted = 0, status = 'pending', session_id = NULL, ai_summary = NULL,
+            read_at = NULL, triggered_by = ?, source = ?, created_at = datetime('now')
+        WHERE watcher_id IS ? AND issue_key = ? AND issue_updated IS ? AND deleted = 1
+        RETURNING id
+      `).get(triggeredBy, source, watcherId, issueKey, issueUpdated) as { id: number } | null;
+      if (resurrected) return { inserted: true, resultId: resurrected.id };
+      return { inserted: false, resultId: null };
+    }
+    throw e;
+  }
+}
+
+export function updateResultStatus(
+  resultId: number,
+  status: JiraResultStatus,
+  updates?: { sessionId?: string; aiSummary?: string },
+): void {
+  const sets = ["status = ?"];
+  const params: (string | number)[] = [status];
+  if (updates?.sessionId !== undefined) { sets.push("session_id = ?"); params.push(updates.sessionId); }
+  if (updates?.aiSummary !== undefined) { sets.push("ai_summary = ?"); params.push(updates.aiSummary); }
+  params.push(resultId);
+  getDb().query(`UPDATE jira_watch_results SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+}
+
+export function getResultsByWatcherId(
+  watcherId?: number,
+  opts?: { status?: string; limit?: number; offset?: number; includeDeleted?: boolean },
+): JiraWatchResult[] {
+  const clauses: string[] = [];
+  const params: (string | number)[] = [];
+  if (watcherId !== undefined) { clauses.push("watcher_id = ?"); params.push(watcherId); }
+  if (opts?.status) { clauses.push("status = ?"); params.push(opts.status); }
+  if (!opts?.includeDeleted) clauses.push("deleted = 0");
+  const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+  const limit = opts?.limit ?? 50;
+  const offset = opts?.offset ?? 0;
+  const rows = getDb()
+    .query(`SELECT * FROM jira_watch_results ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`)
+    .all(...params, limit, offset) as JiraWatchResultRow[];
+  return rows.map(rowToResult);
+}
+
+export function getResultById(id: number): JiraWatchResult | null {
+  const row = getDb().query("SELECT * FROM jira_watch_results WHERE id = ?")
+    .get(id) as JiraWatchResultRow | null;
+  return row ? rowToResult(row) : null;
+}
+
+export function softDeleteResult(id: number): boolean {
+  return getDb().query("UPDATE jira_watch_results SET deleted = 1 WHERE id = ?").run(id).changes > 0;
+}
+
+export function getRunningResults(): JiraWatchResultRow[] {
+  return getDb().query("SELECT * FROM jira_watch_results WHERE status = 'running'")
+    .all() as JiraWatchResultRow[];
+}
+
+export function getWatcherStats(): Record<JiraResultStatus, number> {
+  const rows = getDb().query(
+    "SELECT status, COUNT(*) as count FROM jira_watch_results WHERE deleted = 0 GROUP BY status",
+  ).all() as Array<{ status: JiraResultStatus; count: number }>;
+  const stats: Record<string, number> = { pending: 0, queued: 0, running: 0, done: 0, failed: 0 };
+  for (const r of rows) stats[r.status] = r.count;
+  return stats as Record<JiraResultStatus, number>;
+}
+
+export function markResultRead(resultId: number): boolean {
+  return getDb().query(
+    "UPDATE jira_watch_results SET read_at = datetime('now') WHERE id = ? AND read_at IS NULL",
+  ).run(resultId).changes > 0;
+}
+
+export function getUnreadCount(): number {
+  const row = getDb().query(
+    "SELECT COUNT(*) as count FROM jira_watch_results WHERE status = 'done' AND read_at IS NULL AND deleted = 0",
+  ).get() as { count: number };
+  return row.count;
+}

package/src/services/jira-watcher.service.ts

@@ -0,0 +1,159 @@
+import { searchIssues, JiraApiError, getRateLimitState } from "./jira-api-client.ts";
+import { getDecryptedCredentials } from "./jira-config.service.ts";
+import { getAllEnabledWatchers, insertResult } from "./jira-watcher-db.service.ts";
+import { jiraDebugService } from "./jira-debug-session.service.ts";
+import { getDb } from "./db.service.ts";
+import { notificationService } from "./notification.service.ts";
+import type { JiraWatcherRow, JiraIssue } from "../types/jira.ts";
+
+const INTERVAL_MIN = 30_000;   // 30s
+const INTERVAL_MAX = 3_600_000; // 60m
+const RATE_LIMIT_PAUSE_MS = 300_000; // 5min
+
+export function clampInterval(ms: number): number {
+  return Math.max(INTERVAL_MIN, Math.min(INTERVAL_MAX, ms));
+}
+
+class JiraWatcherService {
+  private activeTimers = new Map<number, Timer>();
+
+  async startAll(): Promise<void> {
+    const watchers = getAllEnabledWatchers();
+    for (const w of watchers) this.startWatcher(w.id, w.interval_ms);
+    if (watchers.length) console.log(`[jira] Started ${watchers.length} watcher(s)`);
+  }
+
+  stopAll(): void {
+    for (const [id, timer] of this.activeTimers) {
+      clearInterval(timer);
+      this.activeTimers.delete(id);
+    }
+  }
+
+  startWatcher(id: number, intervalMs: number): void {
+    if (this.activeTimers.has(id)) this.stopWatcher(id);
+    const interval = clampInterval(intervalMs);
+    const timer = setInterval(() => this.pollWatcher(id).catch((e) =>
+      console.warn(`[jira] Poll error watcher ${id}:`, e.message),
+    ), interval);
+    this.activeTimers.set(id, timer);
+  }
+
+  stopWatcher(id: number): void {
+    const timer = this.activeTimers.get(id);
+    if (timer) { clearInterval(timer); this.activeTimers.delete(id); }
+  }
+
+  isRunning(id: number): boolean {
+    return this.activeTimers.has(id);
+  }
+
+  async pollWatcher(watcherId: number, source: "auto" | "manual" = "auto"): Promise<number> {
+    const watcher = getDb()
+      .query("SELECT * FROM jira_watchers WHERE id = ?")
+      .get(watcherId) as JiraWatcherRow | null;
+    if (!watcher) return 0;
+
+    const creds = getDecryptedCredentials(watcher.jira_config_id);
+    if (!creds) { console.warn(`[jira] No credentials for config ${watcher.jira_config_id}`); return 0; }
+
+    // Check rate limit pause
+    const rlState = getRateLimitState(creds.baseUrl);
+    if (rlState.pausedUntil && Date.now() < rlState.pausedUntil) return 0;
+
+    const isFirstPoll = !watcher.last_polled_at;
+
+    try {
+      // First auto-poll = baseline only: just set last_polled_at, skip inserts
+      // Manual pull always fetches everything
+      if (isFirstPoll && source === "auto") {
+        await searchIssues(creds, watcher.jql); // validate JQL works
+        getDb().query("UPDATE jira_watchers SET last_polled_at = datetime('now') WHERE id = ?").run(watcherId);
+        console.log(`[jira] Watcher "${watcher.name}": baseline poll done (skipped inserts)`);
+        return 0;
+      }
+
+      const response = await searchIssues(creds, watcher.jql);
+      let newCount = 0;
+      const newResultIds: number[] = [];
+
+      for (const issue of response.issues) {
+        let inserted: boolean, resultId: number | null;
+        try {
+          ({ inserted, resultId } = insertResult(
+            watcher.id, issue.key,
+            issue.fields.summary, issue.fields.updated,
+            "watcher", source,
+          ));
+        } catch (e: any) {
+          console.error(`[jira] insertResult FK error for watcher ${watcher.id}, issue ${issue.key}:`, e.message);
+          throw e;
+        }
+        if (inserted && resultId) {
+          newCount++;
+          newResultIds.push(resultId);
+
+          if (watcher.mode === "notify") {
+            notificationService.broadcast("done", {
+              title: `Jira: ${issue.key}`,
+              body: issue.fields.summary,
+              project: "", sessionId: "",
+            }).catch(() => {});
+          }
+        }
+      }
+
+      // Auto-enqueue debug for new issues (≤5 to avoid flooding)
+      if (watcher.mode === "debug" && source === "auto" && newResultIds.length > 0 && newResultIds.length <= 5) {
+        for (const rid of newResultIds) {
+          try { jiraDebugService.enqueue(rid); } catch (e: any) {
+            console.warn(`[jira] enqueue debug error resultId=${rid}:`, e.message);
+          }
+        }
+      }
+
+      // Update last_polled_at
+      getDb().query("UPDATE jira_watchers SET last_polled_at = datetime('now') WHERE id = ?").run(watcherId);
+      if (newCount) console.log(`[jira] Watcher "${watcher.name}": ${newCount} new issue(s)`);
+      return newCount;
+    } catch (e) {
+      if (e instanceof JiraApiError && e.status === 429) {
+        console.warn(`[jira] Rate limited — pausing watchers for config ${watcher.jira_config_id}`);
+        this.pauseConfigWatchers(watcher.jira_config_id);
+      }
+      throw e;
+    }
+  }
+
+  // ── Internal helpers ──────────────────────────────────────────────
+
+  buildPrompt(watcher: JiraWatcherRow, issue: JiraIssue): string {
+    if (watcher.prompt_template) {
+      return watcher.prompt_template
+        .replace(/\{issue_key\}/g, issue.key)
+        .replace(/\{summary\}/g, issue.fields.summary)
+        .replace(/\{description\}/g, issue.fields.description ?? "(no description)")
+        .replace(/\{status\}/g, issue.fields.status.name)
+        .replace(/\{priority\}/g, issue.fields.priority?.name ?? "None");
+    }
+    return `Debug Jira issue ${issue.key}: ${issue.fields.summary}\n\nDescription:\n${issue.fields.description ?? "(no description)"}`;
+  }
+
+  private pauseConfigWatchers(configId: number): void {
+    const watchers = getDb()
+      .query("SELECT id FROM jira_watchers WHERE jira_config_id = ? AND enabled = 1")
+      .all(configId) as Array<{ id: number }>;
+    for (const w of watchers) this.stopWatcher(w.id);
+    // Re-start after pause
+    setTimeout(() => {
+      for (const w of watchers) {
+        const row = getDb().query("SELECT * FROM jira_watchers WHERE id = ? AND enabled = 1")
+          .get(w.id) as JiraWatcherRow | null;
+        if (row) this.startWatcher(row.id, row.interval_ms);
+      }
+    }, RATE_LIMIT_PAUSE_MS);
+  }
+
+}
+
+export const jiraWatcherService = new JiraWatcherService();

package/src/services/notification.service.ts

@@ -13,6 +13,12 @@ export interface NotificationPayload {
 }
 
 class NotificationService {
+  /** Broadcast event to all connected WebSocket clients */
+  async broadcastWs(event: unknown): Promise<void> {
+    const { broadcastGlobalEvent } = await import("../server/ws/chat.ts");
+    broadcastGlobalEvent(event);
+  }
+
   /** Broadcast notification to all channels (push, telegram). Fire-and-forget. */
   async broadcast(_type: NotificationType, payload: NotificationPayload): Promise<void> {
     const tasks: Promise<void>[] = [];

package/src/services/supervisor-state.ts

@@ -55,7 +55,19 @@ export function updateStatus(patch: Record<string, unknown>) {
   try {
     const data = { ...readStatus(), ...patch };
     atomicWriteJson(STATUS_FILE(), data);
-  } catch {}
+  } catch (e) {
+    // Log to stderr so failures are visible in ppm.log
+    try { process.stderr.write(`[updateStatus] Failed to write status.json: ${e}\n`); } catch {}
+  }
+}
+
+/** Full write — replaces entire status.json (use at supervisor startup to clear stale data) */
+export function writeStatus(data: Record<string, unknown>) {
+  try {
+    atomicWriteJson(STATUS_FILE(), data);
+  } catch (e) {
+    try { process.stderr.write(`[writeStatus] Failed to write status.json: ${e}\n`); } catch {}
+  }
 }
 
 // ─── Command file protocol ─────────────────────────────────────────────

package/src/services/supervisor.ts

@@ -15,7 +15,7 @@ import { isCompiledBinary } from "./autostart-generator.ts";
 import {
   type SupervisorState,
   getState, setState, waitForResume, triggerResume,
-  readAndDeleteCmd, readStatus, updateStatus,
+  readAndDeleteCmd, readStatus, updateStatus, writeStatus,
   STATUS_FILE, PID_FILE,
 } from "./supervisor-state.ts";
 import { startStoppedPage, stopStoppedPage } from "./supervisor-stopped-page.ts";
@@ -767,11 +767,12 @@ export async function runSupervisor(opts: {
     log("ERROR", `Unhandled rejection: ${reason}`);
   });
 
-  // Write supervisor PID + clear stale availableVersion from previous run
+  // Full write to clear any stale data from previous runs (different port, dead PIDs, etc.)
   writeFileSync(PID_FILE(), String(process.pid));
-  updateStatus({
+  writeStatus({
     supervisorPid: process.pid, port: opts.port, host: opts.host, availableVersion: null,
     state: "running", pausedAt: null, pauseReason: null, lastCrashError: null,
+    pid: null, tunnelPid: null, shareUrl: null,
   });
 
   // Build __serve__ args

package/src/types/jira.ts

@@ -0,0 +1,128 @@
+// ── DB row types (snake_case, matches SQLite columns) ─────────────────
+
+export interface JiraConfigRow {
+  id: number;
+  project_id: number;
+  base_url: string;
+  email: string;
+  api_token_encrypted: string;
+  created_at: string;
+}
+
+export interface JiraWatcherRow {
+  id: number;
+  jira_config_id: number;
+  name: string;
+  jql: string;
+  prompt_template: string | null;
+  enabled: number; // 0 | 1
+  mode: string; // "debug" | "notify"
+  interval_ms: number;
+  last_polled_at: string | null;
+  created_at: string;
+}
+
+export interface JiraWatchResultRow {
+  id: number;
+  watcher_id: number | null;
+  issue_key: string;
+  issue_summary: string | null;
+  issue_updated: string | null;
+  session_id: string | null;
+  status: JiraResultStatus;
+  ai_summary: string | null;
+  source: string; // "watcher" | "manual"
+  deleted: number; // 0 | 1
+  read_at: string | null;
+  triggered_by: string; // "auto" | "manual"
+  created_at: string;
+}
+
+export type JiraResultStatus = "pending" | "queued" | "running" | "done" | "failed";
+export type JiraWatcherMode = "debug" | "notify";
+
+// ── API response types (camelCase for frontend) ───────────────────────
+
+export interface JiraConfig {
+  id: number;
+  projectId: number;
+  baseUrl: string;
+  email: string;
+  hasToken: boolean; // never expose actual token
+  createdAt: string;
+}
+
+export interface JiraWatcher {
+  id: number;
+  jiraConfigId: number;
+  name: string;
+  jql: string;
+  promptTemplate: string | null;
+  enabled: boolean;
+  mode: JiraWatcherMode;
+  intervalMs: number;
+  lastPolledAt: string | null;
+  createdAt: string;
+}
+
+export interface JiraWatchResult {
+  id: number;
+  watcherId: number | null;
+  issueKey: string;
+  issueSummary: string | null;
+  issueUpdated: string | null;
+  sessionId: string | null;
+  status: JiraResultStatus;
+  aiSummary: string | null;
+  source: string;
+  readAt: string | null;
+  triggeredBy: string;
+  createdAt: string;
+}
+
+// ── Jira Cloud API response shapes (subset we use) ────────────────────
+
+export interface JiraIssue {
+  key: string;
+  id: string;
+  fields: {
+    summary: string;
+    description: string | null;
+    status: { name: string; id: string };
+    priority: { name: string; id: string } | null;
+    assignee: { accountId: string; displayName: string; emailAddress?: string } | null;
+    updated: string;
+    created: string;
+  };
+}
+
+export interface JiraSearchResponse {
+  issues: JiraIssue[];
+  total: number;
+  maxResults: number;
+  nextPageToken?: string;
+}
+
+export interface JiraTransition {
+  id: string;
+  name: string;
+  to: { name: string };
+}
+
+// ── Credentials (internal, decrypted for API calls) ───────────────────
+
+export interface JiraCredentials {
+  baseUrl: string;
+  email: string;
+  token: string; // plaintext (decrypted)
+}
+
+// ── Rate limit tracking ───────────────────────────────────────────────
+
+export interface JiraRateLimitState {
+  remaining: number | null;
+  limit: number | null;
+  resetAt: string | null;
+  backingOff: boolean;
+  pausedUntil: number | null; // epoch ms
+}

package/src/web/app.tsx

@@ -178,19 +178,22 @@ export function App() {
 
       useProjectStore.getState().setActiveProject(target);
 
+      // Switch panel layout to target project BEFORE opening URL tabs.
+      // Without this, autoOpenFromUrl creates tabs in the __global__ layout
+      // which get lost when the switchProject effect fires after render.
+      useTabStore.getState().switchProject(target.name);
+
       // Auto-open target tab from URL (type-based)
-      queueMicrotask(() => {
-        if (urlState.tabType) {
-          autoOpenFromUrl(urlState.tabType, urlState.tabIdentifier, target!.name);
-        }
-        // Legacy: ?openChat= query param
-        if (urlState.openChat) {
-          autoOpenFromUrl("chat", urlState.openChat, target!.name);
-          const url = new URL(window.location.href);
-          url.searchParams.delete("openChat");
-          window.history.replaceState(null, "", url.pathname);
-        }
-      });
+      if (urlState.tabType) {
+        autoOpenFromUrl(urlState.tabType, urlState.tabIdentifier, target!.name);
+      }
+      // Legacy: ?openChat= query param
+      if (urlState.openChat) {
+        autoOpenFromUrl("chat", urlState.openChat, target!.name);
+        const url = new URL(window.location.href);
+        url.searchParams.delete("openChat");
+        window.history.replaceState(null, "", url.pathname);
+      }
     });
   }, [authState, fetchProjects]);
 

package/src/web/components/chat/chat-tab.tsx

@@ -57,6 +57,8 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
   // Drag-and-drop state
   const [isDragging, setIsDragging] = useState(false);
   const [externalFiles, setExternalFiles] = useState<File[] | null>(null);
+  const [externalPaths, setExternalPaths] = useState<string[] | null>(null);
+  const [disambiguateItems, setDisambiguateItems] = useState<FileNode[] | null>(null);
   const dragCounterRef = useRef(0);
 
   // Use tab's own project, not global activeProject (keep-alive: hidden tabs must not react to switches)
@@ -285,6 +287,16 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
     setSlashFilter("");
   }, []);
 
+  // --- Disambiguation picker handler (OS drag resolve with multiple matches) ---
+  const handleDisambiguate = useCallback((matches: FileNode[]) => {
+    setDisambiguateItems(matches);
+  }, []);
+
+  const handleDisambiguateSelect = useCallback((item: FileNode) => {
+    setExternalPaths([item.path]);
+    setDisambiguateItems(null);
+  }, []);
+
   // --- File picker handlers ---
   const handleFileStateChange = useCallback((visible: boolean, filter: string) => {
     setShowFilePicker(visible);
@@ -307,7 +319,7 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
   const handleDragEnter = useCallback((e: DragEvent) => {
     e.preventDefault();
     dragCounterRef.current++;
-    if (e.dataTransfer.types.includes("Files")) {
+    if (e.dataTransfer.types.includes("application/x-ppm-path") || e.dataTransfer.types.includes("Files")) {
       setIsDragging(true);
     }
   }, []);
@@ -329,6 +341,13 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
     dragCounterRef.current = 0;
     setIsDragging(false);
 
+    // Check for internal file tree drag (custom MIME) first
+    const ppmPath = e.dataTransfer.getData("application/x-ppm-path");
+    if (ppmPath) {
+      setExternalPaths([ppmPath]);
+      return;
+    }
+
     const files = Array.from(e.dataTransfer.files);
     if (files.length > 0) {
       setExternalFiles(files);
@@ -422,6 +441,15 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
           onClose={handleFileClose}
           visible={showFilePicker}
         />
+        {disambiguateItems && (
+          <FilePicker
+            items={disambiguateItems}
+            filter=""
+            onSelect={handleDisambiguateSelect}
+            onClose={() => setDisambiguateItems(null)}
+            visible={true}
+          />
+        )}
 
         {/* Input */}
         <MessageInput
@@ -438,6 +466,9 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
           onFileItemsLoaded={setFileItems}
           fileSelected={fileSelected}
           externalFiles={externalFiles}
+          externalPaths={externalPaths}
+          onExternalPathsConsumed={() => setExternalPaths(null)}
+          onDisambiguate={handleDisambiguate}
           permissionMode={permissionMode}
           onModeChange={setPermissionMode}
           providerId={providerId}