mcp-coordinator 0.6.1 → 0.7.0

package/dist/src/consultation.js

@@ -45,7 +45,10 @@ export class Consultation {
     }
     emitResolution(threadId, type, approvedBy, approvedByName) {
         const db = getDb();
-        const thread = this.getThread(threadId);
+        // emitResolution is called internally after we already know the thread belongs
+        // to the right org. We look it up cross-org here intentionally so that
+        // handleAgentDeparture (which is cross-org) can still emit resolution events.
+        const thread = this.getThreadCrossOrg(threadId);
         if (!thread)
             return;
         const messageCount = db.prepare("SELECT COUNT(*) as count FROM thread_messages WHERE thread_id = ?").get(threadId).count;
@@ -59,6 +62,7 @@ export class Consultation {
         if (this.onResolveCallback) {
             this.onResolveCallback({
                 thread_id: threadId,
+                org_id: thread.org_id,
                 resolution_type: type,
                 resolution_summary: thread.resolution_summary,
                 created_at: thread.created_at,
@@ -69,7 +73,7 @@ export class Consultation {
             });
         }
     }
-    announceWork(params) {
+    announceWork(orgId, params) {
         const db = getDb();
         const id = randomUUID();
         // B1 fix: SELECT respondents + INSERT thread must be atomic w.r.t. agent
@@ -79,8 +83,8 @@ export class Consultation {
         // thread then stays open forever waiting for an absent voter.
         const tx = db.transaction(() => {
             const onlineAgents = db
-                .prepare("SELECT id, modules FROM agents WHERE status = 'online' AND id != ?")
-                .all(params.agent_id);
+                .prepare("SELECT id, modules FROM agents WHERE status = 'online' AND id != ? AND org_id = ?")
+                .all(params.agent_id, orgId);
             const respondents = onlineAgents.filter((agent) => {
                 const agentModules = JSON.parse(agent.modules);
                 return params.target_modules.some((tm) => agentModules.some((am) => am === tm || am.startsWith(tm + "/") || tm.startsWith(am + "/")));
@@ -92,13 +96,14 @@ export class Consultation {
             const assignedTo = params.assigned_to ?? null;
             const keepOpen = params.keep_open || assignedTo !== null;
             const autoResolve = respondentIds.length === 0 && !keepOpen;
-            db.prepare(`INSERT INTO threads (id, initiator_id, subject, plan, target_modules, target_files, status, expected_respondents, resolved_at, depends_on_files, exports_affected, timeout_seconds, assigned_to)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, params.agent_id, params.subject, params.plan || null, JSON.stringify(params.target_modules), JSON.stringify(params.target_files), autoResolve ? "resolved" : "open", JSON.stringify(respondentIds), autoResolve ? new Date().toISOString() : null, JSON.stringify(params.depends_on_files || []), JSON.stringify(params.exports_affected || []), keepOpen ? 0 : 600, assignedTo);
+            db.prepare(`INSERT INTO threads (id, org_id, initiator_id, subject, plan, target_modules, target_files, status, expected_respondents, resolved_at, depends_on_files, exports_affected, timeout_seconds, assigned_to)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, orgId, params.agent_id, params.subject, params.plan || null, JSON.stringify(params.target_modules), JSON.stringify(params.target_files), autoResolve ? "resolved" : "open", JSON.stringify(respondentIds), autoResolve ? new Date().toISOString() : null, JSON.stringify(params.depends_on_files || []), JSON.stringify(params.exports_affected || []), keepOpen ? 0 : 600, assignedTo);
             return { autoResolve, respondentIds, assignedTo };
         });
         const { autoResolve, respondentIds, assignedTo } = tx();
         this.log.info({
             thread_id: id,
+            org_id: orgId,
             agent_id: params.agent_id,
             subject: params.subject,
             target_modules: params.target_modules,
@@ -106,11 +111,11 @@ export class Consultation {
             respondent_count: respondentIds.length,
             assigned_to: assignedTo,
         }, "Thread opened");
-        return this.getThread(id);
+        return this.getThread(orgId, id);
     }
-    postToThread(params) {
+    postToThread(orgId, params) {
         const db = getDb();
-        const thread = this.getThread(params.thread_id);
+        const thread = this.getThread(orgId, params.thread_id);
         if (!thread)
             throw new Error(`Thread ${params.thread_id} not found`);
         // Cancelled threads are explicit aborts — reject posts.
@@ -122,8 +127,8 @@ export class Consultation {
         const id = randomUUID();
         // Simple token estimate: ~4 chars per token for English/French
         const tokenEstimate = Math.ceil(params.content.length / 4);
-        db.prepare(`INSERT INTO thread_messages (id, thread_id, agent_id, agent_name, type, content, context_snapshot, in_reply_to, round, token_estimate)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, params.thread_id, params.agent_id, params.agent_name || null, params.type, params.content, params.context_snapshot || null, params.in_reply_to || null, thread.round, tokenEstimate);
+        db.prepare(`INSERT INTO thread_messages (id, org_id, thread_id, agent_id, agent_name, type, content, context_snapshot, in_reply_to, round, token_estimate)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, orgId, params.thread_id, params.agent_id, params.agent_name || null, params.type, params.content, params.context_snapshot || null, params.in_reply_to || null, thread.round, tokenEstimate);
         this.log.debug({
             thread_id: params.thread_id,
             agent_id: params.agent_id,
@@ -132,20 +137,20 @@ export class Consultation {
         }, "Message posted to thread");
         return db.prepare("SELECT * FROM thread_messages WHERE id = ?").get(id);
     }
-    proposeResolution(threadId, agentId, summary) {
+    proposeResolution(orgId, threadId, agentId, summary) {
         const db = getDb();
-        const thread = this.getThread(threadId);
+        const thread = this.getThread(orgId, threadId);
         if (!thread)
             throw new Error(`Thread ${threadId} not found`);
         if (thread.initiator_id !== agentId && thread.claimed_by !== agentId)
             throw new Error("Only the initiator or the claimant can propose a resolution");
-        db.prepare("UPDATE threads SET status = 'resolving', resolution_summary = ? WHERE id = ?").run(summary, threadId);
+        db.prepare("UPDATE threads SET status = 'resolving', resolution_summary = ? WHERE id = ? AND org_id = ?").run(summary, threadId, orgId);
         // Post resolution message
-        this.postResolutionMessage(threadId, agentId, "resolution", summary);
+        this.postResolutionMessage(orgId, threadId, agentId, "resolution", summary);
     }
-    approveResolution(threadId, agentId, agentName) {
+    approveResolution(orgId, threadId, agentId, agentName) {
         const db = getDb();
-        const thread = this.getThread(threadId);
+        const thread = this.getThread(orgId, threadId);
         if (!thread)
             throw new Error(`Thread ${threadId} not found`);
         if (thread.status !== "resolving")
@@ -156,12 +161,12 @@ export class Consultation {
         // the first transaction wins the consensus race; the loser's UPDATE
         // affects 0 rows and emit is suppressed.
         const tx = db.transaction(() => {
-            this.postResolutionMessage(threadId, agentId, "approve", "Approved");
-            if (!this.allRespondentsApproved(threadId))
+            this.postResolutionMessage(orgId, threadId, agentId, "approve", "Approved");
+            if (!this.allRespondentsApproved(orgId, threadId))
                 return false;
             const res = db
-                .prepare("UPDATE threads SET status = 'resolved', resolved_at = ? WHERE id = ? AND status = 'resolving'")
-                .run(new Date().toISOString(), threadId);
+                .prepare("UPDATE threads SET status = 'resolved', resolved_at = ? WHERE id = ? AND org_id = ? AND status = 'resolving'")
+                .run(new Date().toISOString(), threadId, orgId);
             return res.changes > 0;
         });
         const wonRace = tx();
@@ -170,42 +175,42 @@ export class Consultation {
             this.emitResolution(threadId, "consensus", agentId, agentName || agentId);
         }
     }
-    contestResolution(threadId, agentId, reason) {
+    contestResolution(orgId, threadId, agentId, reason) {
         const db = getDb();
-        const thread = this.getThread(threadId);
+        const thread = this.getThread(orgId, threadId);
         if (!thread)
             throw new Error(`Thread ${threadId} not found`);
         if (thread.status !== "resolving")
             throw new Error(`Thread is ${thread.status}, not resolving`);
         // Post contest message
-        this.postResolutionMessage(threadId, agentId, "contest", reason);
+        this.postResolutionMessage(orgId, threadId, agentId, "contest", reason);
         this.log.debug({ thread_id: threadId, agent_id: agentId, reason }, "Resolution contested");
         // Return to open with next round
         const nextRound = thread.round + 1;
         if (nextRound > thread.max_rounds) {
             // Max rounds reached — force resolve
-            db.prepare("UPDATE threads SET status = 'resolved', resolved_at = ? WHERE id = ?").run(new Date().toISOString(), threadId);
+            db.prepare("UPDATE threads SET status = 'resolved', resolved_at = ? WHERE id = ? AND org_id = ?").run(new Date().toISOString(), threadId, orgId);
             this.emitResolution(threadId, "max_rounds");
         }
         else {
-            db.prepare("UPDATE threads SET status = 'open', round = ?, resolution_summary = NULL WHERE id = ?").run(nextRound, threadId);
+            db.prepare("UPDATE threads SET status = 'open', round = ?, resolution_summary = NULL WHERE id = ? AND org_id = ?").run(nextRound, threadId, orgId);
         }
     }
-    cancelThread(threadId, agentId, reason) {
+    cancelThread(orgId, threadId, agentId, reason) {
         const db = getDb();
-        const thread = this.getThread(threadId);
+        const thread = this.getThread(orgId, threadId);
         if (!thread)
             throw new Error(`Thread ${threadId} not found`);
         if (thread.initiator_id !== agentId)
             throw new Error("Only the initiator can cancel");
-        db.prepare("UPDATE threads SET status = 'cancelled', resolved_at = ? WHERE id = ?").run(new Date().toISOString(), threadId);
+        db.prepare("UPDATE threads SET status = 'cancelled', resolved_at = ? WHERE id = ? AND org_id = ?").run(new Date().toISOString(), threadId, orgId);
         if (reason) {
-            this.postResolutionMessage(threadId, agentId, "context", `Cancelled: ${reason}`);
+            this.postResolutionMessage(orgId, threadId, agentId, "context", `Cancelled: ${reason}`);
         }
     }
-    closeThread(threadId, agentId, summary) {
+    closeThread(orgId, threadId, agentId, summary) {
         const db = getDb();
-        const thread = this.getThread(threadId);
+        const thread = this.getThread(orgId, threadId);
         if (!thread) {
             throw new Error(`Thread ${threadId} not found`);
         }
@@ -215,35 +220,54 @@ export class Consultation {
         if (thread.status !== "open" && thread.status !== "resolving") {
             throw new Error(`Cannot close thread ${threadId} in status '${thread.status}'`);
         }
-        db.prepare("UPDATE threads SET status = 'resolved', resolution_summary = ?, resolved_at = ? WHERE id = ?").run(summary, new Date().toISOString(), threadId);
+        db.prepare("UPDATE threads SET status = 'resolved', resolution_summary = ?, resolved_at = ? WHERE id = ? AND org_id = ?").run(summary, new Date().toISOString(), threadId, orgId);
         this.emitResolution(threadId, "closed");
     }
+    /**
+     * Cross-org maintenance sweep — stays at v0.6 signature per Phase 1 plan.
+     * handleAgentDeparture iterates ALL orgs (internal maintenance only).
+     */
     handleAgentDeparture(agentId) {
         const db = getDb();
-        // Unclaim any tasks claimed by the departing agent
+        // Unclaim any tasks claimed by the departing agent.
+        //
+        // INTENTIONALLY cross-org: this method is invoked from the MQTT-bridge
+        // disconnect handler, which has no org context (Phase 1: MQTT topics carry
+        // no org_id yet — see Task 22 follow-up). If two orgs ever happen to
+        // register agents under the same agent_id string, an MQTT disconnect for
+        // that string will release claims in BOTH orgs. Phase 2 multi-org rollout
+        // must thread org from the MQTT topic before this becomes load-bearing.
         db.prepare("UPDATE threads SET claimed_by = NULL, claimed_at = NULL WHERE claimed_by = ? AND status = 'open'")
             .run(agentId);
-        // Remove departed agent from expected_respondents of all open/resolving threads
+        // Remove departed agent from expected_respondents of all open/resolving threads.
+        // We iterate cross-org (no WHERE org_id filter on the SELECT) for the same
+        // reason — agentId is the only key we have from the MQTT bridge — but every
+        // point-update below is scoped by the row's own org_id (read from the SELECT)
+        // as defense in depth against bare id collisions.
         const threads = db
-            .prepare("SELECT id, expected_respondents FROM threads WHERE status IN ('open', 'resolving')")
+            .prepare("SELECT id, org_id, expected_respondents FROM threads WHERE status IN ('open', 'resolving')")
             .all();
         for (const thread of threads) {
             const respondents = JSON.parse(thread.expected_respondents || "[]");
             const updated = respondents.filter((r) => r !== agentId);
-            db.prepare("UPDATE threads SET expected_respondents = ? WHERE id = ?").run(JSON.stringify(updated), thread.id);
+            db.prepare("UPDATE threads SET expected_respondents = ? WHERE id = ? AND org_id = ?").run(JSON.stringify(updated), thread.id, thread.org_id);
             // If resolving and all remaining approved, resolve
-            const t = this.getThread(thread.id);
-            if (t.status === "resolving" && this.allRespondentsApproved(thread.id)) {
-                db.prepare("UPDATE threads SET status = 'resolved', resolved_at = ? WHERE id = ?").run(new Date().toISOString(), thread.id);
+            const t = this.getThreadCrossOrg(thread.id);
+            if (t.status === "resolving" && this.allRespondentsApproved(thread.org_id, thread.id)) {
+                db.prepare("UPDATE threads SET status = 'resolved', resolved_at = ? WHERE id = ? AND org_id = ?").run(new Date().toISOString(), thread.id, thread.org_id);
                 this.emitResolution(thread.id, "agent_departure");
             }
             // If open and no respondents left, auto-resolve
             if (t.status === "open" && updated.length === 0) {
-                db.prepare("UPDATE threads SET status = 'resolved', resolved_at = ? WHERE id = ?").run(new Date().toISOString(), thread.id);
+                db.prepare("UPDATE threads SET status = 'resolved', resolved_at = ? WHERE id = ? AND org_id = ?").run(new Date().toISOString(), thread.id, thread.org_id);
                 this.emitResolution(thread.id, "agent_departure");
             }
         }
     }
+    /**
+     * Cross-org sweeper — stays at v0.6 signature per Phase 1 plan.
+     * checkTimeouts scans ALL orgs (internal maintenance only).
+     */
     checkTimeouts() {
         const db = getDb();
         // B2 fix: SELECT-then-UPDATE wrapped in a transaction so two concurrent
@@ -279,28 +303,28 @@ export class Consultation {
             this.emitResolution(t.id, "timeout");
         }
     }
-    getThread(threadId) {
+    getThread(orgId, threadId) {
         // B2 fix: timeout sweeping moved to startTimeoutSweeper() background timer.
         // Reads no longer mutate state. Tests that need synchronous timeout
         // resolution should call checkTimeouts() explicitly.
         const db = getDb();
-        return (db.prepare("SELECT * FROM threads WHERE id = ?").get(threadId) || null);
+        return (db.prepare("SELECT * FROM threads WHERE id = ? AND org_id = ?").get(threadId, orgId) || null);
     }
-    getThreadWithMessages(threadId) {
-        const thread = this.getThread(threadId);
+    getThreadWithMessages(orgId, threadId) {
+        const thread = this.getThread(orgId, threadId);
         if (!thread)
             return null;
         const db = getDb();
         const messages = db
-            .prepare("SELECT * FROM thread_messages WHERE thread_id = ? ORDER BY created_at")
-            .all(threadId);
+            .prepare("SELECT tm.* FROM thread_messages tm JOIN threads t ON tm.thread_id = t.id WHERE tm.thread_id = ? AND t.org_id = ? ORDER BY tm.created_at")
+            .all(threadId, orgId);
         return { thread, messages };
     }
-    listThreads(filters) {
+    listThreads(orgId, filters) {
         // B2 fix: removed checkTimeouts() side-effect; sweeper handles it.
         const db = getDb();
-        let sql = "SELECT * FROM threads WHERE 1=1";
-        const params = [];
+        let sql = "SELECT * FROM threads WHERE org_id = ?";
+        const params = [orgId];
         if (filters.status) {
             sql += " AND status = ?";
             params.push(filters.status);
@@ -331,13 +355,14 @@ export class Consultation {
         sql += " ORDER BY created_at DESC";
         return db.prepare(sql).all(...params);
     }
-    getThreadUpdates(agentId, since) {
+    getThreadUpdates(orgId, agentId, since) {
         const db = getDb();
         let sql = `SELECT tm.* FROM thread_messages tm
                JOIN threads t ON tm.thread_id = t.id
-               WHERE t.status IN ('open', 'resolving')
+               WHERE t.org_id = ?
+               AND t.status IN ('open', 'resolving')
                AND tm.agent_id != ?`;
-        const params = [agentId];
+        const params = [orgId, agentId];
         if (since) {
             sql += " AND tm.created_at >= ?";
             // Normalize ANY parseable ISO/date string (including timezone offsets
@@ -354,17 +379,17 @@ export class Consultation {
         sql += " ORDER BY tm.created_at";
         return db.prepare(sql).all(...params);
     }
-    logActionSummary(params) {
+    logActionSummary(orgId, params) {
         const db = getDb();
         const id = randomUUID();
-        db.prepare(`INSERT INTO action_summaries (id, session_id, agent_id, file_path, summary)
-       VALUES (?, ?, ?, ?, ?)`).run(id, params.session_id, params.agent_id, params.file_path || null, params.summary);
+        db.prepare(`INSERT INTO action_summaries (id, org_id, session_id, agent_id, file_path, summary)
+       VALUES (?, ?, ?, ?, ?, ?)`).run(id, orgId, params.session_id, params.agent_id, params.file_path || null, params.summary);
         return db.prepare("SELECT * FROM action_summaries WHERE id = ?").get(id);
     }
-    getActionSummaries(agentId, since) {
+    getActionSummaries(orgId, agentId, since) {
         const db = getDb();
-        let sql = "SELECT * FROM action_summaries WHERE agent_id = ?";
-        const params = [agentId];
+        let sql = "SELECT * FROM action_summaries WHERE org_id = ? AND agent_id = ?";
+        const params = [orgId, agentId];
         if (since) {
             sql += " AND created_at > ?";
             params.push(since);
@@ -372,23 +397,31 @@ export class Consultation {
         sql += " ORDER BY created_at DESC";
         return db.prepare(sql).all(...params);
     }
-    getActionSummariesBySession(sessionId) {
+    getActionSummariesBySession(orgId, sessionId) {
         const db = getDb();
         return db
-            .prepare("SELECT * FROM action_summaries WHERE session_id = ? ORDER BY created_at")
-            .all(sessionId);
+            .prepare("SELECT * FROM action_summaries WHERE org_id = ? AND session_id = ? ORDER BY created_at")
+            .all(orgId, sessionId);
     }
     // ── Private helpers ──
-    postResolutionMessage(threadId, agentId, type, content) {
+    /**
+     * Cross-org thread lookup for internal sweepers/departure handlers.
+     * Do NOT call from public methods — use getThread(orgId, id) instead.
+     */
+    getThreadCrossOrg(threadId) {
+        const db = getDb();
+        return (db.prepare("SELECT * FROM threads WHERE id = ?").get(threadId) || null);
+    }
+    postResolutionMessage(orgId, threadId, agentId, type, content) {
         const db = getDb();
-        const thread = this.getThread(threadId);
+        const thread = this.getThread(orgId, threadId);
         const id = randomUUID();
-        db.prepare(`INSERT INTO thread_messages (id, thread_id, agent_id, type, content, round)
-       VALUES (?, ?, ?, ?, ?, ?)`).run(id, threadId, agentId, type, content, thread.round);
+        db.prepare(`INSERT INTO thread_messages (id, org_id, thread_id, agent_id, type, content, round)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`).run(id, orgId, threadId, agentId, type, content, thread.round);
     }
-    allRespondentsApproved(threadId) {
+    allRespondentsApproved(orgId, threadId) {
         const db = getDb();
-        const thread = this.getThread(threadId);
+        const thread = this.getThread(orgId, threadId);
         const expected = JSON.parse(thread.expected_respondents || "[]");
         if (expected.length === 0)
             return true;

package/dist/src/context-provider.d.ts

@@ -3,12 +3,12 @@ import type { AgentRegistry } from "./agent-registry.js";
 import type { Consultation } from "./consultation.js";
 import type { FileTracker } from "./file-tracker.js";
 export interface ContextProvider {
-    getRelevantContext(agentId: string, query: ConsultationAnnounce): AgentContext;
+    getRelevantContext(orgId: string, agentId: string, query: ConsultationAnnounce): AgentContext;
 }
 export declare class SummaryContextProvider implements ContextProvider {
     private registry;
     private consultation;
     private fileTracker;
     constructor(registry: AgentRegistry, consultation: Consultation, fileTracker: FileTracker);
-    getRelevantContext(agentId: string, query: ConsultationAnnounce): AgentContext;
+    getRelevantContext(orgId: string, agentId: string, query: ConsultationAnnounce): AgentContext;
 }

package/dist/src/context-provider.js

@@ -7,8 +7,8 @@ export class SummaryContextProvider {
         this.consultation = consultation;
         this.fileTracker = fileTracker;
     }
-    getRelevantContext(agentId, query) {
-        const agent = this.registry.get(agentId);
+    getRelevantContext(orgId, agentId, query) {
+        const agent = this.registry.get(orgId, agentId);
         if (!agent) {
             return { agent_id: agentId, modules: [], recent_files: [], action_summaries: [] };
         }
@@ -18,8 +18,7 @@ export class SummaryContextProvider {
         if (overlapping.length === 0) {
             return { agent_id: agentId, modules: [], recent_files: [], action_summaries: [] };
         }
-        // Get action summaries for this agent
-        const summaries = this.consultation.getActionSummaries(agentId);
+        const summaries = this.consultation.getActionSummaries(orgId, agentId);
         // Get recent files from action summaries (agent writes these via MCP tool)
         const recentFiles = summaries
             .filter((s) => s.file_path)

package/dist/src/database.js

@@ -1,9 +1,9 @@
 import path from "path";
-import { mkdirSync } from "fs";
+import { mkdirSync, chmodSync } from "fs";
 import { createRequire } from "module";
 const require = createRequire(import.meta.url);
 let db;
-const CURRENT_USER_VERSION = 6;
+const CURRENT_USER_VERSION = 7;
 const SCHEMA = `
     CREATE TABLE IF NOT EXISTS agents (
       id TEXT PRIMARY KEY,
@@ -169,6 +169,71 @@ const SCHEMA = `
     );
     CREATE INDEX IF NOT EXISTS idx_firings_layer  ON layer_firings(layer, fired_at);
     CREATE INDEX IF NOT EXISTS idx_firings_thread ON layer_firings(thread_id);
+
+    CREATE TABLE IF NOT EXISTS orgs (
+      id            TEXT PRIMARY KEY,
+      name          TEXT NOT NULL,
+      idp_provider  TEXT,
+      idp_org_id    TEXT,
+      created_at    TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE TABLE IF NOT EXISTS users (
+      id              TEXT PRIMARY KEY,
+      org_id          TEXT NOT NULL REFERENCES orgs(id),
+      email           TEXT NOT NULL,
+      name            TEXT,
+      idp_provider    TEXT NOT NULL,
+      idp_user_id     TEXT NOT NULL,
+      role            TEXT NOT NULL DEFAULT 'member',
+      created_at      TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      last_login_at   TEXT,
+      UNIQUE(idp_provider, idp_user_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_users_org ON users(org_id);
+
+    CREATE TABLE IF NOT EXISTS refresh_tokens (
+      id              TEXT PRIMARY KEY,
+      org_id          TEXT NOT NULL REFERENCES orgs(id),
+      user_id         TEXT NOT NULL REFERENCES users(id),
+      jti             TEXT NOT NULL UNIQUE,
+      device_label    TEXT,
+      expires_at      TEXT NOT NULL,
+      revoked_at      TEXT,
+      last_used_at    TEXT,
+      created_at      TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
+    CREATE INDEX IF NOT EXISTS idx_refresh_user ON refresh_tokens(user_id, revoked_at);
+    CREATE INDEX IF NOT EXISTS idx_refresh_org_user ON refresh_tokens(org_id, user_id, revoked_at);
+
+    CREATE TABLE IF NOT EXISTS device_auth_requests (
+      device_code      TEXT PRIMARY KEY,
+      user_code        TEXT NOT NULL UNIQUE,
+      nonce            TEXT NOT NULL UNIQUE,
+      approved_user_id TEXT REFERENCES users(id),
+      org_id           TEXT,
+      expires_at       TEXT NOT NULL,
+      created_at       TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
+    CREATE INDEX IF NOT EXISTS idx_device_user_code ON device_auth_requests(user_code);
+    CREATE INDEX IF NOT EXISTS idx_device_nonce ON device_auth_requests(nonce);
+
+    CREATE TABLE IF NOT EXISTS audit_log (
+      id              INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id         TEXT,
+      org_id          TEXT,
+      action          TEXT NOT NULL,
+      target          TEXT,
+      ip              TEXT,
+      user_agent      TEXT,
+      metadata        TEXT,
+      created_at      TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
+    CREATE INDEX IF NOT EXISTS idx_audit_org_time ON audit_log(org_id, created_at);
+    CREATE INDEX IF NOT EXISTS idx_audit_user ON audit_log(user_id, created_at);
+    CREATE INDEX IF NOT EXISTS idx_audit_action ON audit_log(action, created_at);
+
+    INSERT OR IGNORE INTO orgs (id, name) VALUES ('default', 'Default Organization');
 `;
 function createBetterSqlite3(dataDir) {
     mkdirSync(dataDir, { recursive: true });
@@ -212,6 +277,13 @@ export function initDatabase(dataDir) {
         throw new Error(`Database schema is from a newer version (${foundVersion}) than this binary supports (${CURRENT_USER_VERSION}). Downgrade not supported.`);
     }
     db.exec(SCHEMA);
+    // v0.7 security baseline: only owner can read/write the DB file.
+    // Idempotent re-chmod on every boot so existing v0.6 DBs are tightened too.
+    // POSIX-only: chmod is a no-op on Windows (NTFS permissions don't map).
+    try {
+        chmodSync(path.join(dataDir, "coordinator.db"), 0o600);
+    }
+    catch { /* non-POSIX or permission error — log-only would be too noisy */ }
     // Migrations for existing databases — columns may already exist
     try {
         db.exec("ALTER TABLE threads ADD COLUMN claimed_by TEXT");
@@ -245,8 +317,135 @@ export function initDatabase(dataDir) {
         db.exec("ALTER TABLE file_activity ADD COLUMN content_hash TEXT");
     }
     catch { /* already exists */ }
-    // v0.6: schema version marker. Used by cli/server/restore.ts to refuse downgrades.
-    db.exec("PRAGMA user_version = 6");
+    // v0.7: multi-tenant org_id column on every table that participates in scoping.
+    // SQLite lacks online DDL — each ALTER briefly blocks writes. Migration is
+    // idempotent (already-exists is caught silently).
+    // SECURITY: `t` is from a compile-time constant array only — never user input.
+    const TABLES_NEEDING_ORG = [
+        "agents", "threads", "thread_messages", "action_summaries",
+        "file_activity", "events", "dependency_map", "introspections",
+        "agent_activity_status", "revoked_agents", "working_files",
+        "git_cochange", "git_cochange_meta", "layer_firings",
+    ];
+    for (const t of TABLES_NEEDING_ORG) {
+        try {
+            db.exec(`ALTER TABLE ${t} ADD COLUMN org_id TEXT NOT NULL DEFAULT 'default'`);
+        }
+        catch { /* already exists */ }
+    }
+    // v0.7: scan index for events table — getEventsSince queries by (org_id, id)
+    try {
+        db.exec("CREATE INDEX IF NOT EXISTS idx_events_org_id ON events(org_id, id)");
+    }
+    catch { /* already exists */ }
+    // v0.7: SQLite lacks ALTER PRIMARY KEY. Pattern per table:
+    //   1. Create new table with composite PK.
+    //   2. Copy all rows from old to new.
+    //   3. Drop old.
+    //   4. Rename new to old.
+    //   5. Recreate indexes.
+    // Idempotent: skip if the table's PK already includes org_id.
+    function migrateToCompositePK(targetDb, tableName, newCreateSql, columnList, indexCreateSqls) {
+        // Check if migration already happened by inspecting PK columns
+        const cols = targetDb.prepare(`PRAGMA table_info(${tableName})`).all();
+        const pkCols = cols.filter((c) => c.pk > 0).map((c) => c.name);
+        if (pkCols.includes("org_id"))
+            return; // already migrated
+        // SQLite: FK enforcement blocks DROP TABLE when other tables hold FK refs.
+        // PRAGMA foreign_keys must be toggled OUTSIDE the transaction (it's a no-op
+        // inside an open transaction). The finally block guarantees FKs are re-enabled
+        // even on error to avoid permanent corruption.
+        targetDb.exec("PRAGMA foreign_keys = OFF");
+        try {
+            targetDb.exec("BEGIN");
+            try {
+                targetDb.exec(newCreateSql.replace(tableName, `${tableName}_new`));
+                targetDb.exec(`INSERT INTO ${tableName}_new (${columnList}) SELECT ${columnList} FROM ${tableName}`);
+                targetDb.exec(`DROP TABLE ${tableName}`);
+                targetDb.exec(`ALTER TABLE ${tableName}_new RENAME TO ${tableName}`);
+                for (const idxSql of indexCreateSqls)
+                    targetDb.exec(idxSql);
+                targetDb.exec("COMMIT");
+            }
+            catch (e) {
+                targetDb.exec("ROLLBACK");
+                throw e;
+            }
+        }
+        finally {
+            targetDb.exec("PRAGMA foreign_keys = ON");
+        }
+    }
+    migrateToCompositePK(db, "agents", `CREATE TABLE agents (
+      id TEXT NOT NULL,
+      org_id TEXT NOT NULL DEFAULT 'default',
+      name TEXT NOT NULL,
+      modules TEXT DEFAULT '[]',
+      status TEXT DEFAULT 'offline',
+      registered_at TEXT DEFAULT CURRENT_TIMESTAMP,
+      last_seen_at TEXT DEFAULT CURRENT_TIMESTAMP,
+      PRIMARY KEY (org_id, id)
+    )`, "id, org_id, name, modules, status, registered_at, last_seen_at", ["CREATE UNIQUE INDEX IF NOT EXISTS idx_agents_id ON agents(id)"]);
+    migrateToCompositePK(db, "agent_activity_status", `CREATE TABLE agent_activity_status (
+      agent_id TEXT NOT NULL,
+      org_id TEXT NOT NULL DEFAULT 'default',
+      activity_status TEXT DEFAULT 'idle',
+      current_file TEXT,
+      current_thread TEXT,
+      last_activity_at TEXT DEFAULT CURRENT_TIMESTAMP,
+      FOREIGN KEY (agent_id) REFERENCES agents(id),
+      PRIMARY KEY (org_id, agent_id)
+    )`, "agent_id, org_id, activity_status, current_file, current_thread, last_activity_at", []);
+    migrateToCompositePK(db, "revoked_agents", `CREATE TABLE revoked_agents (
+      agent_id TEXT NOT NULL,
+      org_id TEXT NOT NULL DEFAULT 'default',
+      revoked_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      revoked_by TEXT NOT NULL,
+      PRIMARY KEY (org_id, agent_id)
+    )`, "agent_id, org_id, revoked_at, revoked_by", []);
+    migrateToCompositePK(db, "working_files", `CREATE TABLE working_files (
+      agent_id TEXT NOT NULL,
+      file_path TEXT NOT NULL,
+      org_id TEXT NOT NULL DEFAULT 'default',
+      started_at TEXT NOT NULL,
+      last_activity_at TEXT NOT NULL,
+      claim_until TEXT NOT NULL,
+      PRIMARY KEY (org_id, agent_id, file_path)
+    )`, "agent_id, file_path, org_id, started_at, last_activity_at, claim_until", [
+        "CREATE INDEX IF NOT EXISTS idx_working_files_path  ON working_files(file_path)",
+        "CREATE INDEX IF NOT EXISTS idx_working_files_until ON working_files(claim_until)",
+    ]);
+    migrateToCompositePK(db, "dependency_map", `CREATE TABLE dependency_map (
+      module_id TEXT NOT NULL,
+      org_id TEXT NOT NULL DEFAULT 'default',
+      depends_on TEXT DEFAULT '[]',
+      exports TEXT DEFAULT '[]',
+      owners TEXT DEFAULT '[]',
+      PRIMARY KEY (org_id, module_id)
+    )`, "module_id, org_id, depends_on, exports, owners", []);
+    migrateToCompositePK(db, "git_cochange", `CREATE TABLE git_cochange (
+      file_a TEXT NOT NULL,
+      file_b TEXT NOT NULL,
+      org_id TEXT NOT NULL DEFAULT 'default',
+      count INTEGER NOT NULL,
+      total_commits INTEGER NOT NULL,
+      computed_at TEXT NOT NULL,
+      PRIMARY KEY (org_id, file_a, file_b),
+      CHECK (file_a < file_b)
+    )`, "file_a, file_b, org_id, count, total_commits, computed_at", [
+        "CREATE INDEX IF NOT EXISTS idx_cochange_a ON git_cochange(file_a)",
+        "CREATE INDEX IF NOT EXISTS idx_cochange_b ON git_cochange(file_b)",
+    ]);
+    migrateToCompositePK(db, "git_cochange_meta", `CREATE TABLE git_cochange_meta (
+      k TEXT NOT NULL,
+      org_id TEXT NOT NULL DEFAULT 'default',
+      v TEXT,
+      PRIMARY KEY (org_id, k)
+    )`, "k, org_id, v", []);
+    // v0.7: bump version marker LAST — after every CREATE TABLE and ALTER above succeeded.
+    // A crash before this line leaves user_version=6 and the next boot retries the migration
+    // (idempotent). Bumping earlier would make a partial migration look complete.
+    db.exec("PRAGMA user_version = 7");
 }
 export function getDb() {
     if (!db)