@overscore/cli 0.9.14 → 0.10.1

package/dist/index.js

@@ -47,7 +47,29 @@ function loadEnv() {
             };
         }
     }
-    console.error("  Error: No credentials found. Run 'npx @overscore/cli auth login' to set up.");
+    // No creds. Tailor the message based on what kind of folder we're in so the
+    // user gets pointed at the right setup command.
+    const inAnalysisFolder = fs.existsSync(path.resolve(process.cwd(), ".overscore", "analysis.json"));
+    if (inAnalysisFolder) {
+        let analysisSlug = null;
+        try {
+            const meta = JSON.parse(fs.readFileSync(path.resolve(process.cwd(), ".overscore", "analysis.json"), "utf-8"));
+            analysisSlug = typeof meta.slug === "string" ? meta.slug : null;
+        }
+        catch {
+            // Fall through to the generic message.
+        }
+        console.error("\n  Error: No credentials found in this analysis folder.");
+        console.error("  This usually means the analysis hasn't been linked to your account yet.");
+        console.error("  Run:");
+        console.error(`    npx @overscore/cli analysis pull ${analysisSlug || "<slug>"}`);
+        console.error("  to refresh credentials and link this folder, or:");
+        console.error("    npx @overscore/cli auth login");
+        console.error("  if you've never set up the CLI on this machine.\n");
+    }
+    else {
+        console.error("\n  Error: No credentials found. Run 'npx @overscore/cli auth login' to set up.\n");
+    }
     process.exit(1);
 }
 async function apiRequest(method, urlPath, body) {
@@ -239,7 +261,10 @@ async function deploy() {
     // Sync context files to Hub
     const { projectSlug } = loadEnv();
     const baseUrl = apiUrl.replace(/\/api$/, "");
-    // Sync company context (with conflict detection)
+    // Upload knowledge base (project-level, shared across all artifacts)
+    await uploadKnowledgeBase(process.cwd(), baseUrl, projectSlug, apiKey);
+    // Sync company context (with conflict detection) — legacy path for
+    // projects that haven't migrated to the knowledge base yet.
     const companyCtxPath = path.resolve(process.cwd(), ".claude/rules/company-context.md");
     if (fs.existsSync(companyCtxPath)) {
         const content = fs.readFileSync(companyCtxPath, "utf-8");
@@ -282,9 +307,11 @@ async function deploy() {
         }
     }
     // Sync dashboard context (no conflict detection needed — per-dashboard)
-    const dashCtxPath = path.resolve(process.cwd(), ".claude/rules/dashboard-context.md");
-    if (fs.existsSync(dashCtxPath)) {
-        const content = fs.readFileSync(dashCtxPath, "utf-8");
+    const dashCtxPath = path.resolve(process.cwd(), ".claude/rules/this-dashboard.md");
+    const legacyDashCtxPath = path.resolve(process.cwd(), ".claude/rules/dashboard-context.md");
+    const activeDashCtxPath = fs.existsSync(dashCtxPath) ? dashCtxPath : fs.existsSync(legacyDashCtxPath) ? legacyDashCtxPath : null;
+    if (activeDashCtxPath) {
+        const content = fs.readFileSync(activeDashCtxPath, "utf-8");
         try {
             await fetch(`${baseUrl}/api/dashboards/${dashboardSlug}/context`, {
                 method: "PUT",
@@ -307,21 +334,43 @@ async function queryList() {
     const { dashboardSlug } = loadEnv();
     const data = (await apiRequest("GET", `/api/dashboards/${dashboardSlug}/queries`));
     console.log(`\n  Dashboard: ${data.dashboard}\n`);
+    // Registered queries
     if (data.queries.length === 0) {
         console.log("  No queries registered yet.\n");
-        console.log("  Add one with:");
-        console.log('    npx @overscore/cli query add <name> "SELECT ..."\n');
-        return;
+        console.log("  Add a SQL query:  npx @overscore/cli query add <name> \"SELECT ...\"\n");
     }
-    for (const q of data.queries) {
-        const rowInfo = q.row_count !== null ? ` (~${q.row_count.toLocaleString()} rows)` : "";
-        console.log(`  ${q.query_name}${rowInfo}`);
-        console.log(`    useQuery("${q.query_name}")`);
-        if (q.sample_row) {
-            const cols = Object.keys(q.sample_row).join(", ");
-            console.log(`    columns: ${cols}`);
+    else {
+        console.log("  Registered Queries:\n");
+        for (const q of data.queries) {
+            const rowInfo = q.row_count !== null ? ` (~${q.row_count.toLocaleString()} rows)` : "";
+            const sourceTag = q.source === "dataset" ? " [dataset]" : "";
+            console.log(`  ${q.query_name}${rowInfo}${sourceTag}`);
+            console.log(`    useQuery("${q.query_name}")`);
+            if (q.sample_row) {
+                const cols = Object.keys(q.sample_row).join(", ");
+                console.log(`    columns: ${cols}`);
+            }
+            else if (q.columns && q.columns.length > 0) {
+                const cols = q.columns.map((c) => `${c.name} (${c.type})`).join(", ");
+                console.log(`    columns: ${cols}`);
+            }
+            console.log();
+        }
+    }
+    // Project datasets (always shown)
+    if (data.project_datasets && data.project_datasets.length > 0) {
+        console.log("  Project Datasets:\n");
+        for (const ds of data.project_datasets) {
+            const rowInfo = ds.row_count !== null ? ` (~${ds.row_count.toLocaleString()} rows)` : "";
+            const sampleTag = ds.is_sample ? " [sample]" : "";
+            console.log(`  ${ds.name}${rowInfo}${sampleTag}`);
+            if (ds.columns && ds.columns.length > 0) {
+                const cols = ds.columns.map((c) => `${c.name} (${c.type})`).join(", ");
+                console.log(`    columns: ${cols}`);
+            }
+            console.log(`    To use: npx @overscore/cli query add <query-name> --dataset ${ds.name}`);
+            console.log();
         }
-        console.log();
     }
 }
 async function queryShow(name) {
@@ -343,16 +392,28 @@ async function queryShow(name) {
     }
     console.log(`\n  ${query.query_name}`);
     if (query.row_count !== null) {
-        console.log(`  ~${query.row_count.toLocaleString()} rows\n`);
+        console.log(`  ~${query.row_count.toLocaleString()} rows`);
     }
-    else {
-        console.log();
+    if (query.source === "dataset" && query.dataset_name) {
+        console.log(`  source: uploaded dataset (${query.dataset_name})`);
+    }
+    console.log();
+    if (query.source === "dataset") {
+        if (query.columns && query.columns.length > 0) {
+            console.log(`  Columns:`);
+            for (const col of query.columns) {
+                console.log(`    ${col.name}  (${col.type})`);
+            }
+            console.log();
+        }
     }
-    console.log(`  SQL:`);
-    console.log(`  ${query.sql}\n`);
-    if (query.sample_row) {
-        console.log(`  Sample row:`);
-        console.log(`  ${JSON.stringify(query.sample_row, null, 2).split("\n").join("\n  ")}\n`);
+    else if (query.sql) {
+        console.log(`  SQL:`);
+        console.log(`  ${query.sql}\n`);
+        if (query.sample_row) {
+            console.log(`  Sample row:`);
+            console.log(`  ${JSON.stringify(query.sample_row, null, 2).split("\n").join("\n  ")}\n`);
+        }
     }
 }
 function resolveSql(sqlOrNext) {
@@ -369,10 +430,15 @@ function resolveSql(sqlOrNext) {
     return sqlOrNext;
 }
 async function queryAdd(name, sql) {
+    // Check for --dataset flag
+    const datasetFlagIndex = process.argv.indexOf("--dataset");
+    const datasetName = datasetFlagIndex !== -1 ? process.argv[datasetFlagIndex + 1] : undefined;
     const resolvedSql = resolveSql(sql);
-    if (!name || !resolvedSql) {
+    if (!name || (!resolvedSql && !datasetName)) {
         console.error('\n  Usage: npx @overscore/cli query add <name> "<sql>"\n');
-        console.error("  Or with a file:");
+        console.error("  Or link an uploaded dataset:");
+        console.error("    npx @overscore/cli query add <name> --dataset <dataset-name>\n");
+        console.error("  Or with a SQL file:");
         console.error("    npx @overscore/cli query add <name> --file query.sql\n");
         process.exit(1);
     }
@@ -381,7 +447,26 @@ async function queryAdd(name, sql) {
         process.exit(1);
     }
     const { dashboardSlug } = loadEnv();
-    const data = (await apiRequest("POST", `/api/dashboards/${dashboardSlug}/queries`, { query_name: name, sql_text: resolvedSql }));
+    let body;
+    if (datasetName) {
+        // Look up the dataset UUID from project_datasets in the queries endpoint
+        const listData = (await apiRequest("GET", `/api/dashboards/${dashboardSlug}/queries`));
+        const dataset = (listData.project_datasets ?? []).find((ds) => ds.name === datasetName);
+        if (!dataset) {
+            console.error(`\n  Error: Dataset "${datasetName}" not found in this project.\n`);
+            console.error("  Available datasets:");
+            for (const ds of listData.project_datasets ?? []) {
+                console.error(`    - ${ds.name}`);
+            }
+            console.error();
+            process.exit(1);
+        }
+        body = { query_name: name, dataset_id: dataset.id };
+    }
+    else {
+        body = { query_name: name, sql_text: resolvedSql };
+    }
+    const data = (await apiRequest("POST", `/api/dashboards/${dashboardSlug}/queries`, body));
     console.log(`\n  Query "${data.query_name}" created.\n`);
     console.log(`  Use it in your dashboard:`);
     console.log(`    const { data } = useQuery("${data.query_name}");\n`);
@@ -413,16 +498,34 @@ async function queryRemove(name) {
     await apiRequest("DELETE", `/api/dashboards/${dashboardSlug}/queries/${encodeURIComponent(name)}`);
     console.log(`\n  Query "${name}" deleted.\n`);
 }
-function saveQueryResult(sql, data) {
+function saveQueryResult(sql, data, sourceFile) {
     try {
         const hash = createHash("sha256").update(sql).digest("hex").slice(0, 8);
-        const snippet = sql
-            .toLowerCase()
-            .replace(/[^a-z0-9_]+/g, "_")
-            .replace(/^_|_$/g, "")
-            .slice(0, 40);
-        const filename = `${hash}_${snippet}.json`;
         const dataDir = path.resolve(process.cwd(), "data");
+        // Check for ANY existing file with this hash — handles both old and new
+        // filename formats so the same query isn't duplicated.
+        if (fs.existsSync(dataDir)) {
+            const existing = fs.readdirSync(dataDir).find((f) => f.includes(hash) && f.endsWith(".json"));
+            if (existing) {
+                return { path: `data/${existing}`, cached: true };
+            }
+        }
+        // Build filename: human-readable prefix when from a file, hash prefix otherwise
+        let filename;
+        if (sourceFile) {
+            const baseName = path.basename(sourceFile, path.extname(sourceFile));
+            filename = `${baseName}__${hash}.json`;
+        }
+        else {
+            const snippet = sql
+                .toLowerCase()
+                .replace(/[^a-z0-9_]+/g, "_")
+                .replace(/^_|_$/g, "")
+                .slice(0, 40);
+            filename = `${hash}_${snippet}.json`;
+        }
+        const fullPath = path.join(dataDir, filename);
+        const relPath = `data/${filename}`;
         if (!fs.existsSync(dataDir)) {
             fs.mkdirSync(dataDir, { recursive: true });
         }
@@ -434,27 +537,55 @@ function saveQueryResult(sql, data) {
             columns: data.data.length > 0 ? Object.keys(data.data[0]) : [],
             data: data.data,
         };
-        fs.writeFileSync(path.join(dataDir, filename), JSON.stringify(payload, null, 2));
-        return `data/${filename}`;
+        fs.writeFileSync(fullPath, JSON.stringify(payload, null, 2));
+        return { path: relPath, cached: false };
     }
     catch {
         return null;
     }
 }
 async function queryTest(sql) {
-    if (!sql) {
-        console.error('\n  Usage: npx @overscore/cli query test "<sql>"\n');
-        console.error("  Example:");
-        console.error('    npx @overscore/cli query test "SELECT * FROM dataset.table LIMIT 10"\n');
+    const resolvedSql = resolveSql(sql);
+    if (!resolvedSql) {
+        console.error('\n  Usage: npx @overscore/cli query run "<sql>"\n');
+        console.error("  Or with a file:");
+        console.error("    npx @overscore/cli query run --file queries/foo.sql\n");
         process.exit(1);
     }
     const { projectSlug } = loadEnv();
-    const data = (await apiRequest("POST", `/api/projects/${projectSlug}/test-query`, { sql }));
-    const savedPath = saveQueryResult(sql, data);
+    if (!projectSlug) {
+        const analysisMetaPath = path.resolve(process.cwd(), ".overscore", "analysis.json");
+        if (fs.existsSync(analysisMetaPath)) {
+            let slug = "<slug>";
+            try {
+                const meta = JSON.parse(fs.readFileSync(analysisMetaPath, "utf-8"));
+                if (typeof meta.slug === "string")
+                    slug = meta.slug;
+            }
+            catch {
+                // ignore
+            }
+            console.error("\n  Error: This analysis folder isn't linked to a project yet.");
+            console.error(`  Run: npx @overscore/cli analysis pull ${slug}\n`);
+        }
+        else {
+            console.error("\n  Error: No project slug configured. Run 'npx @overscore/cli auth login' to set one up.\n");
+        }
+        process.exit(1);
+    }
+    const data = (await apiRequest("POST", `/api/projects/${projectSlug}/test-query`, { sql: resolvedSql }));
+    const fileIndex = process.argv.indexOf("--file");
+    const sourceFile = fileIndex !== -1 ? process.argv[fileIndex + 1] : undefined;
+    const saved = saveQueryResult(resolvedSql, data, sourceFile);
+    const savedLine = saved
+        ? saved.cached
+            ? `  Cached (already saved earlier): ${saved.path}`
+            : `  Saved to ${saved.path}`
+        : null;
     console.log(`\n  ${data.row_count} rows returned${data.truncated ? " (showing first 200)" : ""}\n`);
     if (data.data.length === 0) {
-        if (savedPath)
-            console.log(`  Saved to ${savedPath}\n`);
+        if (savedLine)
+            console.log(`${savedLine}\n`);
         console.log("  No rows.\n");
         return;
     }
@@ -481,8 +612,8 @@ async function queryTest(sql) {
     if (data.data.length > 10) {
         console.log(`\n  ... and ${data.data.length - 10} more rows`);
     }
-    if (savedPath)
-        console.log(`\n  Saved to ${savedPath}`);
+    if (savedLine)
+        console.log(`\n${savedLine}`);
     console.log();
 }
 function formatCell(value) {
@@ -601,7 +732,7 @@ VITE_OVERSCORE_API_URL=https://overscore.dev/api
             if (dashCtxData.context_md) {
                 const rulesDir = path.join(targetDir, ".claude", "rules");
                 fs.mkdirSync(rulesDir, { recursive: true });
-                fs.writeFileSync(path.join(rulesDir, "dashboard-context.md"), dashCtxData.context_md);
+                fs.writeFileSync(path.join(rulesDir, "this-dashboard.md"), dashCtxData.context_md);
                 console.log("  Updated dashboard context from Hub.");
             }
         }
@@ -833,19 +964,23 @@ async function syncHubManagedRules(targetDir, baseUrl, projectSlug, apiKey) {
     const authHeader = { Authorization: `Bearer ${apiKey}` };
     const rulesDir = path.join(targetDir, ".claude", "rules");
     fs.mkdirSync(rulesDir, { recursive: true });
-    // Company context — null means "no company context set yet"; leave any
-    // existing file alone in that case.
-    try {
-        const ctxRes = await fetch(`${baseUrl}/api/projects/${projectSlug}/context`, { headers: authHeader });
-        if (ctxRes.ok) {
-            const ctxData = (await ctxRes.json());
-            if (ctxData.context_md) {
-                fs.writeFileSync(path.join(rulesDir, "company-context.md"), ctxData.context_md);
+    // Try knowledge base first — if the project has knowledge files, they
+    // replace the legacy company-context.md.
+    const hasKnowledge = await syncKnowledgeBase(targetDir, baseUrl, projectSlug, apiKey);
+    // Company context — only fetch if no knowledge files exist (legacy path).
+    if (!hasKnowledge) {
+        try {
+            const ctxRes = await fetch(`${baseUrl}/api/projects/${projectSlug}/context`, { headers: authHeader });
+            if (ctxRes.ok) {
+                const ctxData = (await ctxRes.json());
+                if (ctxData.context_md) {
+                    fs.writeFileSync(path.join(rulesDir, "company-context.md"), ctxData.context_md);
+                }
             }
         }
-    }
-    catch {
-        // Non-fatal
+        catch {
+            // Non-fatal
+        }
     }
     // SQL style override — null means "use the CLI default"; leave the
     // template/bundle file alone in that case.
@@ -862,6 +997,93 @@ async function syncHubManagedRules(targetDir, baseUrl, projectSlug, apiKey) {
         // Non-fatal
     }
 }
+/**
+ * Sync the project knowledge base from the Hub into .claude/knowledge/.
+ * Returns true if knowledge files were found (caller can skip legacy
+ * company-context.md in that case).
+ */
+async function syncKnowledgeBase(targetDir, baseUrl, projectSlug, apiKey) {
+    const authHeader = { Authorization: `Bearer ${apiKey}` };
+    const knowledgeDir = path.join(targetDir, ".claude", "knowledge");
+    try {
+        const res = await fetch(`${baseUrl}/api/projects/${projectSlug}/knowledge`, { headers: authHeader });
+        if (!res.ok)
+            return false;
+        const data = (await res.json());
+        if (!data.files || data.files.length === 0)
+            return false;
+        fs.mkdirSync(knowledgeDir, { recursive: true });
+        // Write each knowledge file
+        for (const file of data.files) {
+            fs.writeFileSync(path.join(knowledgeDir, file.path), file.content);
+        }
+        // Generate INDEX.md
+        const indexLines = [
+            "# Project Knowledge Base",
+            "",
+            "Read the relevant file when working on a topic. Do NOT read all files every session.",
+            "",
+        ];
+        for (const file of data.files) {
+            indexLines.push(`- **${file.title}**: \`.claude/knowledge/${file.path}\``);
+        }
+        indexLines.push("");
+        fs.writeFileSync(path.join(knowledgeDir, "INDEX.md"), indexLines.join("\n"));
+        // Store hashes for conflict detection on upload
+        const hashMap = {};
+        for (const file of data.files) {
+            hashMap[file.path] = file.content_hash;
+        }
+        fs.writeFileSync(path.join(knowledgeDir, ".knowledge-hashes"), JSON.stringify(hashMap, null, 2));
+        console.log(`  Knowledge base synced (${data.files.length} files).`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Upload local knowledge files back to the Hub.
+ * Called from deploy/publish so knowledge learned during a session persists.
+ */
+async function uploadKnowledgeBase(targetDir, baseUrl, projectSlug, apiKey) {
+    const knowledgeDir = path.join(targetDir, ".claude", "knowledge");
+    if (!fs.existsSync(knowledgeDir))
+        return;
+    const files = [];
+    for (const entry of fs.readdirSync(knowledgeDir)) {
+        // Skip INDEX.md (auto-generated) and dotfiles (.knowledge-hashes)
+        if (entry === "INDEX.md" ||
+            entry.startsWith(".") ||
+            !entry.endsWith(".md"))
+            continue;
+        const content = fs.readFileSync(path.join(knowledgeDir, entry), "utf-8");
+        // Extract title from first H1 line, fallback to filename
+        const titleMatch = content.match(/^#\s+(.+)$/m);
+        const title = titleMatch
+            ? titleMatch[1]
+            : entry.replace(/\.md$/, "").replace(/[-_]/g, " ");
+        files.push({ path: entry, title, content });
+    }
+    if (files.length === 0)
+        return;
+    try {
+        const res = await fetch(`${baseUrl}/api/projects/${projectSlug}/knowledge`, {
+            method: "PUT",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ files }),
+        });
+        if (res.ok) {
+            console.log(`  Knowledge base synced (${files.length} files).`);
+        }
+    }
+    catch {
+        // Non-fatal
+    }
+}
 /**
  * Fetch the latest platform-owned Claude Code rules from the Hub and write
  * them into the project's .claude/ directory. This keeps rules like
@@ -869,8 +1091,8 @@ async function syncHubManagedRules(targetDir, baseUrl, projectSlug, apiKey) {
  * projects that were scaffolded months ago.
  *
  * Called from `deploy` (before uploading) and `pull` (after extracting).
- * User-owned files (company-context.md, dashboard-context.md) are NOT
- * touched — those sync via separate mechanisms.
+ * User-owned files (company-context.md, this-dashboard.md, knowledge/)
+ * are NOT touched — those sync via separate mechanisms.
  */
 async function syncPlatformRules(targetDir, baseUrl, apiKey) {
     try {
@@ -913,18 +1135,22 @@ function scaffoldFromTemplate(templateDir, targetDir, substitutions) {
         }
         return out;
     }
+    const TEMPLATE_RENAMES = {
+        _gitignore: ".gitignore",
+        _overscoreignore: ".overscoreignore",
+    };
     function walk(srcDir, destDir) {
         fs.mkdirSync(destDir, { recursive: true });
         for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
             const srcPath = path.join(srcDir, entry.name);
-            const destName = entry.name === "_gitignore" ? ".gitignore" : entry.name;
+            const destName = TEMPLATE_RENAMES[entry.name] || entry.name;
             const destPath = path.join(destDir, destName);
             if (entry.isDirectory()) {
                 walk(srcPath, destPath);
             }
             else if (entry.isFile()) {
                 const ext = path.extname(entry.name).toLowerCase();
-                if (TEXT_EXTENSIONS.has(ext) || entry.name === "_gitignore") {
+                if (TEXT_EXTENSIONS.has(ext) || TEMPLATE_RENAMES[entry.name]) {
                     const content = fs.readFileSync(srcPath, "utf8");
                     fs.writeFileSync(destPath, substitute(content));
                 }
@@ -1011,23 +1237,77 @@ function loadAnalysisMetadata() {
     }
     return JSON.parse(fs.readFileSync(metaPath, "utf-8"));
 }
-const ANALYSIS_PUBLISH_EXCLUDE = new Set([
+// Always-excluded names — these can never be published regardless of
+// .overscoreignore, so secrets and machine-state can't accidentally ship.
+const ANALYSIS_PUBLISH_BASELINE_EXCLUDE = new Set([
     "node_modules",
     ".git",
     ".DS_Store",
-    ".env",
-    "data",
+    ".overscore",
 ]);
-function collectAnalysisFiles(dir, prefix) {
+function isBaselineExcluded(name) {
+    if (ANALYSIS_PUBLISH_BASELINE_EXCLUDE.has(name))
+        return true;
+    if (name.startsWith(".env"))
+        return true;
+    return false;
+}
+function compileIgnorePattern(raw) {
+    let pattern = raw.trim();
+    if (!pattern || pattern.startsWith("#"))
+        return null;
+    const dirOnly = pattern.endsWith("/");
+    if (dirOnly)
+        pattern = pattern.slice(0, -1);
+    // Escape regex specials except for `*`, then turn `*` into `[^/]*`.
+    const escaped = pattern
+        .split("*")
+        .map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&"))
+        .join("[^/]*");
+    // Anchor to either a full path match or a path that has the pattern as a
+    // path segment somewhere (so `data/` matches `data/foo.json` and `*.email.html`
+    // matches `emails/x.email.html`).
+    const regex = new RegExp(`(^|/)${escaped}(/|$)`);
+    return { raw, regex, dirOnly };
+}
+function loadOverscoreIgnore(dir) {
+    const ignorePath = path.join(dir, ".overscoreignore");
+    if (!fs.existsSync(ignorePath))
+        return [];
+    const content = fs.readFileSync(ignorePath, "utf-8");
+    const patterns = [];
+    for (const line of content.split("\n")) {
+        const compiled = compileIgnorePattern(line);
+        if (compiled)
+            patterns.push(compiled);
+    }
+    return patterns;
+}
+function isIgnored(relativePath, isDirectory, patterns) {
+    for (const p of patterns) {
+        if (p.dirOnly && !isDirectory) {
+            // Directory-only pattern can still match a file *inside* the directory.
+            // The regex handles that case for paths like `data/foo.json`.
+            if (p.regex.test(relativePath))
+                return true;
+        }
+        else if (p.regex.test(relativePath)) {
+            return true;
+        }
+    }
+    return false;
+}
+function collectAnalysisFiles(dir, prefix, patterns) {
+    const userPatterns = patterns ?? loadOverscoreIgnore(dir);
     const files = [];
     for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        if (ANALYSIS_PUBLISH_EXCLUDE.has(entry.name))
-            continue;
-        if (entry.name.startsWith(".env"))
+        if (isBaselineExcluded(entry.name))
             continue;
         const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (isIgnored(relativePath, entry.isDirectory(), userPatterns))
+            continue;
         if (entry.isDirectory()) {
-            files.push(...collectAnalysisFiles(path.join(dir, entry.name), relativePath));
+            files.push(...collectAnalysisFiles(path.join(dir, entry.name), relativePath, userPatterns));
         }
         else {
             files.push(relativePath);
@@ -1035,7 +1315,61 @@ function collectAnalysisFiles(dir, prefix) {
     }
     return files;
 }
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+function summarizeFiles(files, baseDir) {
+    const groupMap = new Map();
+    let totalBytes = 0;
+    for (const rel of files) {
+        const fullPath = path.join(baseDir, rel);
+        let size = 0;
+        try {
+            size = fs.statSync(fullPath).size;
+        }
+        catch {
+            // skip stat failures, count as 0
+        }
+        totalBytes += size;
+        const segments = rel.split("/");
+        const group = segments.length > 1 ? segments[0] + "/" : "(root)";
+        let entry = groupMap.get(group);
+        if (!entry) {
+            entry = { group, files: [], totalBytes: 0 };
+            groupMap.set(group, entry);
+        }
+        entry.files.push({ path: rel, size });
+        entry.totalBytes += size;
+    }
+    // Sort groups: (root) first, then alphabetical
+    const groups = Array.from(groupMap.values()).sort((a, b) => {
+        if (a.group === "(root)")
+            return -1;
+        if (b.group === "(root)")
+            return 1;
+        return a.group.localeCompare(b.group);
+    });
+    return { groups, totalFiles: files.length, totalBytes };
+}
+function printBundleSummary(files, baseDir, opts = {}) {
+    const { groups, totalFiles, totalBytes } = summarizeFiles(files, baseDir);
+    for (const group of groups) {
+        const fileWord = group.files.length === 1 ? "file" : "files";
+        console.log(`    ${group.group}  ${group.files.length} ${fileWord}, ${formatBytes(group.totalBytes)}`);
+        if (opts.verbose) {
+            for (const f of group.files) {
+                console.log(`      ${f.path}  (${formatBytes(f.size)})`);
+            }
+        }
+    }
+    console.log(`    ${"─".repeat(20)}\n    Total: ${totalFiles} files, ${formatBytes(totalBytes)}`);
+}
 async function analysisPublish() {
+    const dryRun = process.argv.includes("--dry-run") || process.argv.includes("--preview");
     const meta = loadAnalysisMetadata();
     if (!meta.project_slug) {
         console.error("\n  Error: analysis.json has no project_slug. Check .overscore/analysis.json.\n");
@@ -1045,6 +1379,27 @@ async function analysisPublish() {
         console.error("\n  Error: analysis.json has no slug. Check .overscore/analysis.json.\n");
         process.exit(1);
     }
+    const reportPath = path.resolve(process.cwd(), "report.html");
+    if (!fs.existsSync(reportPath)) {
+        console.error("\n  Error: report.html not found in this folder. Generate it before publishing.\n");
+        process.exit(1);
+    }
+    const reportContent = fs.readFileSync(reportPath, "utf-8");
+    if (reportContent.includes("This analysis is empty")) {
+        console.error("\n  Error: report.html still has placeholder content. Generate the report before publishing.\n");
+        process.exit(1);
+    }
+    // Dry-run: print what would be uploaded, then exit. No network, no auth.
+    if (dryRun) {
+        const files = collectAnalysisFiles(process.cwd(), "");
+        console.log(`\n  Dry run — these files would be uploaded for "${meta.title}":\n`);
+        printBundleSummary(files, process.cwd(), { verbose: true });
+        console.log(`
+  Excluded by .overscoreignore + baseline (.git, node_modules, .env*, .overscore/, .DS_Store).
+  No upload made. Re-run without --dry-run to publish.
+`);
+        return;
+    }
     const cfg = await loadAnalysisConfig();
     // Resolve missing id from the Hub before giving up
     if (!meta.id) {
@@ -1058,16 +1413,6 @@ async function analysisPublish() {
         }
         meta.id = refreshed.id;
     }
-    const reportPath = path.resolve(process.cwd(), "report.html");
-    if (!fs.existsSync(reportPath)) {
-        console.error("\n  Error: report.html not found in this folder. Generate it before publishing.\n");
-        process.exit(1);
-    }
-    const reportContent = fs.readFileSync(reportPath, "utf-8");
-    if (reportContent.includes("This analysis is empty")) {
-        console.error("\n  Error: report.html still has placeholder content. Generate the report before publishing.\n");
-        process.exit(1);
-    }
     console.log(`\n  Publishing analysis: ${meta.title}\n`);
     const files = collectAnalysisFiles(process.cwd(), "");
     console.log(`  Bundling ${files.length} files...`);
@@ -1091,12 +1436,11 @@ async function analysisPublish() {
         console.error(`\n  Publish failed: ${data.error}\n`);
         process.exit(1);
     }
-    console.log(`
-  Published successfully!
-
-  ${data.file_count} files uploaded
-  URL: ${data.url}
-`);
+    console.log(`\n  Published successfully!\n`);
+    printBundleSummary(files, process.cwd());
+    console.log(`\n    URL: ${data.url}\n`);
+    // Upload knowledge base so insights from this analysis persist
+    await uploadKnowledgeBase(process.cwd(), baseUrl, meta.project_slug, cfg.apiKey);
 }
 /**
  * Ensure analysis.json has a valid id by fetching from the Hub.
@@ -1350,8 +1694,30 @@ async function analysisPull(slug) {
         await ensureAnalysisId(targetDir, cfg, analysisSlug);
     }
     if (!inPlace) {
+        // Summarize what landed on disk so the user knows what they got.
+        let pulledFileCount = 0;
+        let pulledBytes = 0;
+        try {
+            const pulledFiles = collectAnalysisFiles(targetDir, "");
+            pulledFileCount = pulledFiles.length;
+            for (const f of pulledFiles) {
+                try {
+                    pulledBytes += fs.statSync(path.join(targetDir, f)).size;
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        catch {
+            // collection failed — fall back to no summary
+        }
+        const sizeSummary = pulledFileCount > 0
+            ? `  Pulled into ./${analysisSlug} (${pulledFileCount} files, ${formatBytes(pulledBytes)})`
+            : `  Pulled into ./${analysisSlug}`;
         console.log(`
   Pulled "${analysisTitle}"
+${sizeSummary}
 
   Next steps:
 
@@ -1367,6 +1733,28 @@ async function analysisPull(slug) {
 `);
     }
 }
+function analysisPreview() {
+    const reportPath = path.resolve(process.cwd(), "report.html");
+    if (!fs.existsSync(reportPath)) {
+        console.error("\n  Error: report.html not found in this folder. Generate it before previewing.\n");
+        process.exit(1);
+    }
+    // Windows `start` needs an empty quoted title before the path arg
+    // (`start "" "C:\path\report.html"`), which is why we prefix it here.
+    const opener = process.platform === "darwin"
+        ? "open"
+        : process.platform === "win32"
+            ? 'start ""'
+            : "xdg-open";
+    try {
+        execSync(`${opener} "${reportPath}"`, { stdio: "inherit" });
+        console.log(`\n  Opened ${path.basename(reportPath)} in your default browser.\n`);
+    }
+    catch {
+        console.error(`\n  Error: couldn't run "${opener}". Open ${reportPath} manually.\n`);
+        process.exit(1);
+    }
+}
 // ── auth ────────────────────────────────────────────────────────────
 async function authStatus() {
     const configDir = path.join(process.env.HOME || "", ".overscore");
@@ -1575,19 +1963,26 @@ else if (command === "analysis") {
     else if (subcommand === "pull") {
         analysisPull(process.argv[4]);
     }
+    else if (subcommand === "preview") {
+        analysisPreview();
+    }
     else {
         console.log(`
   overscore analysis — Manage Overscore Analyses (frozen investigations)
 
   Commands:
-    new "<title>"     Create a new analysis in the current directory
-    publish           Upload report.html + bundle from the current analysis folder
-    pull <slug>       Re-download an existing analysis bundle to continue working
+    new "<title>"            Create a new analysis in the current directory
+    publish                  Upload report.html + bundle from the current analysis folder
+    publish --dry-run        Print what would be uploaded without sending it
+    pull <slug>              Re-download an existing analysis bundle to continue working
+    preview                  Open report.html in your default browser
 
   Examples:
     npx @overscore/cli analysis new "Why did Q1 churn spike"
     npx @overscore/cli analysis publish
+    npx @overscore/cli analysis publish --dry-run
     npx @overscore/cli analysis pull why-did-q1-churn-spike
+    npx @overscore/cli analysis preview
 `);
     }
 }
@@ -1615,21 +2010,23 @@ else if (command === "query") {
   overscore query — Manage dashboard queries
 
   Commands:
-    list                     List all queries
-    show <name>              Show a query's SQL and sample data
-    add <name> "<sql>"       Add a new query
-    update <name> "<sql>"    Update a query's SQL
-    remove <name>            Delete a query
-    run "<sql>"              Run SQL against BigQuery
-    test "<sql>"             Alias for run
+    list                          List all queries
+    show <name>                   Show a query's SQL and sample data
+    add <name> "<sql>"            Add a SQL query
+    add <name> --dataset <name>   Link an uploaded dataset as a query
+    update <name> "<sql>"         Update a query's SQL
+    remove <name>                 Delete a query
+    run "<sql>"                   Run SQL against BigQuery
+    run --file <path>             Run SQL from a file (e.g. queries/foo.sql)
+    test                          Alias for run
 
   Examples:
     npx @overscore/cli query list
     npx @overscore/cli query show monthly_revenue
     npx @overscore/cli query add monthly_revenue --file queries/revenue.sql
-    npx @overscore/cli query add monthly_revenue "SELECT ..."
     npx @overscore/cli query update monthly_revenue --file queries/revenue.sql
     npx @overscore/cli query run "SELECT * FROM dataset.table LIMIT 10"
+    npx @overscore/cli query run --file queries/q3-cohort-halo.sql
 `);
     }
 }
@@ -1660,9 +2057,12 @@ else {
     npx @overscore/cli query update <name> "<sql>"
     npx @overscore/cli query remove <name>
     npx @overscore/cli query run "<sql>"
+    npx @overscore/cli query run --file queries/foo.sql
     npx @overscore/cli analysis new "<title>"
     npx @overscore/cli analysis publish
+    npx @overscore/cli analysis publish --dry-run
     npx @overscore/cli analysis pull <slug>
+    npx @overscore/cli analysis preview
     npx @overscore/cli install-skills
 `);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@overscore/cli",
-  "version": "0.9.14",
+  "version": "0.10.1",
   "description": "CLI for deploying Overscore dashboards and publishing analyses",
   "bin": {
     "overscore": "dist/index.js"

package/skills/save-knowledge/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: save-knowledge
+description: Reviews data insights discovered during dashboard or analysis work and proposes additions to the project knowledge base. Use before deploying a dashboard or publishing an analysis, when the user says "save what you learned", or after discovering non-obvious data facts like timezone quirks, column semantics, dedup rules, or metric definitions.
+---
+
+# Save Knowledge
+
+Run this skill before deploying a dashboard or when explicitly asked.
+
+## When to invoke
+- Before `npx @overscore/cli deploy`
+- When the user says "save what you learned" or similar
+
+## Process
+
+1. Review the dashboard code and any exploratory queries you ran.
+
+2. Read `.claude/knowledge/INDEX.md` to see what's already documented.
+
+3. For each new insight, decide:
+   - **Project knowledge** (helps ALL future artifacts) → propose addition to `.claude/knowledge/`
+   - **Dashboard-specific** (design decision, query note) → append to `.claude/rules/this-dashboard.md`
+   - **Already known** → skip
+
+4. Present proposed additions to the user for approval before writing any files.
+
+## What qualifies as project knowledge vs dashboard-specific
+- "dates are UTC-7 no DST" → project knowledge (helps all artifacts)
+- "affiliate_id = 0 is unattributed" → project knowledge
+- "Revenue chart excludes refunds per Finance definition" → dashboard-specific
+- "Default filter is 90 days for CFO's current-quarter view" → dashboard-specific

package/skills/scaffold-overscore-artifact/SKILL.md

@@ -1,6 +1,8 @@
 ---
 name: scaffold-overscore-artifact
-description: Use when the user wants to create a new Overscore dashboard or analysis, or when they're inside one artifact type and want to switch to the other (e.g. "turn this analysis into a dashboard", "do a quick analysis on this dashboard's data", "I want to investigate why X happened", "I want to track X over time"). Follow this procedure to scaffold the new artifact in the correct location with the correct command and seed it with context from the current artifact.
+description: Routes users to the correct Overscore artifact type (Dashboard vs Analysis) and scaffolds it in the right location. Dashboards track metrics forever with live data; Analyses answer a question once with a static HTML report.
+when_to_use: Use when the user wants to create a new dashboard or analysis, or when they're inside one artifact type and want to switch to the other. Trigger phrases include "build a dashboard", "track X over time", "create an analysis", "investigate why X", "turn this into a dashboard", "do a quick analysis", "I want to monitor", "I need a report on".
+argument-hint: "[dashboard or analysis description]"
 ---
 
 # Scaffolding Overscore Artifacts

package/templates/analysis/.claude/CLAUDE.md

@@ -31,6 +31,12 @@ Use the Overscore CLI to run SQL against the project's BigQuery connection:
 npx @overscore/cli query run "SELECT col1, COUNT(*) FROM \`project.dataset.table\` WHERE date >= '2024-01-01' GROUP BY 1 LIMIT 100"
 ```
 
+For longer queries, write the SQL to a file in `queries/` and pass `--file`:
+
+```bash
+npx @overscore/cli query run --file queries/q3-cohort-halo.sql
+```
+
 The CLI authenticates via `~/.overscore/config` (set up on first use). Credentials are stored in the Hub — never hardcode them locally.
 
 **Rules for exploratory queries:**
@@ -39,24 +45,46 @@ The CLI authenticates via `~/.overscore/config` (set up on first use). Credentia
 - Pre-aggregate before pulling wide result sets
 - Do NOT use `query list`, `query add`, or `query show` — those are for dashboard registered queries, not analysis exploration
 
-**Previous query results are saved automatically.** Every `query run` saves the full result set to `data/` as a JSON file. Before re-running a query, check `data/` — the results may already be there from a previous session. Read them with standard file tools instead of re-querying BigQuery.
+**Previous query results are saved automatically.** Every `query run` saves the full result set to `data/` as a JSON file, keyed by a hash of the SQL. Re-running an identical query is a no-op — the CLI prints `Cached (already saved earlier): data/...` instead of writing a duplicate. Before re-running a query, check `data/` — the results may already be there from a previous session. Read them with standard file tools instead of re-querying BigQuery.
+
+## Saving final queries
+
+The `queries/` directory is for SQL files you want to keep around — the canonical version of each Q-numbered query in `analysis-log.md`, queries the user might want to re-run later, or anything you've iterated on enough to deserve a name. File names like `q3-cohort-halo.sql` cross-reference the Query Log. Exploratory one-offs don't need to live here; they're already saved as JSON in `data/`.
 
-## Where data context lives
+## Project Knowledge Base
 
-`.claude/rules/company-context.md` was pulled from this analysis's parent project at scaffold time. It contains the project's table definitions, business logic, and data quirks shared across all dashboards and analyses in this project. **Read it first** before exploring blindly.
+`.claude/knowledge/INDEX.md` lists all knowledge files for this project — table definitions,
+business logic, metric formulas, data quirks. **Read INDEX.md before starting any data work.**
+Only read the specific files relevant to your current task.
+
+When you discover something non-obvious (a timezone gotcha, a dedup rule, a column that means
+something unexpected), **propose adding it to the knowledge base**:
+- Create a new `.claude/knowledge/{topic}.md` file (one topic per file, 20-80 lines)
+- Or append to an existing file if the topic matches
+- Update INDEX.md when you add or remove a file
+
+Knowledge files sync to the Hub on `analysis publish` and are shared with every artifact
+in this project. Good knowledge notes help every future session.
 
 ## Previewing
 
 To preview the report at any point, open it in the browser:
 
 ```bash
-open report.html        # macOS
-start report.html       # Windows
-xdg-open report.html    # Linux
+npx @overscore/cli analysis preview
 ```
 
+(Or `open report.html` / `start report.html` / `xdg-open report.html` if the CLI isn't handy.)
+
 Preview early and often — don't write the entire report before checking the layout. Build section by section, previewing after each major addition.
 
+## If the user wants a share email or Slack message
+
+If the user asks for a copy-paste email or Slack summary of the analysis, write it to a file like `update-YYYY-MM-DD.email.html` in the analysis root. Two things to know:
+
+- **Email-safe HTML only.** Gmail and most clients strip `<style>` blocks — use inline styles on every element. No `<script>` (most clients block it). Keep layouts simple; complex things (multi-column) want `<table>` for cross-client compatibility.
+- **The `.email.html` suffix keeps it out of the published bundle.** It's matched by `.overscoreignore`, so iterating on email drafts won't pollute the public report.
+
 ## Publishing
 
 When the analysis is ready, **tell the user to run** (do not run it yourself without asking):
@@ -79,4 +107,4 @@ The following files in `.claude/rules/` load automatically when you touch matchi
 - **`report-html.md`** — Self-contained HTML rules and dark-theme spec (loads when editing `report.html`)
 - **`report-components.md`** — Copy-paste HTML/SVG component snippets: KPI cards, charts, tables, heatmaps (loads when editing `report.html`)
 - **`analysis-methodology.md`** — Investigation loop, when to ask vs query (loads when editing `analysis-log.md`)
-- **`company-context.md`** — Project-level data context (loaded every session)
+- **`knowledge/INDEX.md`** — Project knowledge base catalog (read before data work)

package/templates/analysis/.claude/rules/analysis-methodology.md

@@ -77,4 +77,8 @@ When starting `report.html`, read only the **Key Findings** section of `analysis
 
 ## Cached query results
 
-Every `query run` command saves its result to `data/{hash}_{snippet}.json`. At the start of a session, check `data/` for existing results before re-running queries — especially after a context reset or `analysis pull`. The JSON files contain the SQL, timestamp, columns, and full row data. Read them directly instead of re-querying BigQuery.
+Every `query run` command saves its result to `data/{hash}_{snippet}.json`. The hash is derived from the SQL string, so re-running an identical query is a no-op — the CLI prints `Cached (already saved earlier): data/...` instead of writing a duplicate. At the start of a session, check `data/` for existing results before re-running queries — especially after a context reset or `analysis pull`. The JSON files contain the SQL, timestamp, columns, and full row data. Read them directly instead of re-querying BigQuery.
+
+## Saving queries to disk
+
+For any query worth referencing later (each Q-numbered query in this log, queries the user might re-run, longer queries you've iterated on), save the SQL to `queries/qN-short-name.sql` and run it via `npx @overscore/cli query run --file queries/qN-short-name.sql`. The Query Log entry then just needs the file reference instead of a full SQL paste — it keeps the log readable and gives you a single source of truth to edit. Throwaway one-shot exploratory queries don't need a file; their JSON in `data/` is enough.

package/templates/analysis/.claude/rules/report-html.md

@@ -80,4 +80,11 @@ A good analysis report has these sections in order:
 </html>
 ```
 
+**Mobile responsiveness.** Reports are often opened on phones from Slack links. The skeleton's `max-width: 900px` and viewport meta tag handle the basics, but also:
+- Use `clamp()` or media queries for KPI font sizes (`font-size: clamp(1.5rem, 5vw, 2.5rem)`) so they don't overflow on 375px screens.
+- KPI card grids should wrap: `display: grid; grid-template-columns: repeat(auto-fit, minmax(140px, 1fr))`.
+- Tables need `overflow-x: auto` on their container.
+- Padding: `2rem` is fine on desktop but use `padding: 2rem 1rem` on mobile via `@media (max-width: 480px)`.
+- Charts (SVG): set `width="100%" viewBox="..."` and let them scale, or use `max-width: 100%`.
+
 **Always preview `report.html` in a browser and get the user's approval before publishing.**

package/templates/analysis/.claude/skills/save-knowledge/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: save-knowledge
+description: Reviews data insights discovered during analysis work and proposes additions to the project knowledge base. Use before publishing an analysis, when the user says "save what you learned", or after discovering non-obvious data facts like timezone quirks, column semantics, dedup rules, or metric definitions.
+---
+
+# Save Knowledge
+
+Run this skill before publishing an analysis or when explicitly asked.
+
+## When to invoke
+- Before `analysis publish` (review what you learned first)
+- When the user says "save what you learned" or similar
+
+## Process
+
+1. Review `analysis-log.md` — look for non-obvious data facts you discovered:
+   - Column semantics that weren't obvious from the name
+   - Timezone, dedup, or join gotchas
+   - Metric definitions or business rules
+   - Data quality issues or known gaps
+
+2. Read `.claude/knowledge/INDEX.md` to see what's already documented.
+
+3. For each new insight, decide:
+   - **Project knowledge** (helps ALL future artifacts) → propose a new file or addition to `.claude/knowledge/`
+   - **Already known** (in an existing knowledge file) → skip
+   - **Analysis-specific** (only relevant to this investigation) → leave in analysis-log.md
+
+4. Present proposed additions to the user for approval before writing any files.
+
+5. After approval, write the files and update INDEX.md.
+
+## What qualifies as project knowledge
+- "unique_page_views is already COUNT(DISTINCT domain_userid)" → YES
+- "date_az is America/Phoenix UTC-7, no DST" → YES
+- "affiliate_id = 0 is unattributed, usually exclude" → YES
+- "Q1 churn spiked because of the pricing change" → NO (analysis conclusion, not data fact)
+- "I used a 90-day window for this analysis" → NO (analysis-specific decision)

package/templates/analysis/.claude/skills/start-analysis/SKILL.md

@@ -1,6 +1,11 @@
 ---
 name: start-analysis
-description: Use at the start of any new Overscore analysis BEFORE querying data. Interviews the user about the question, known data sources, success criteria, and hypotheses, then writes an initial analysis-log.md entry and proposes a query plan for approval. Trigger when analysis-log.md has no queries logged yet.
+description: Interviews the user before querying data at the start of a new Overscore analysis. Captures the real question, known tables, success criteria, hypotheses, time window, and data quirks, then writes an initial analysis-log.md entry and proposes a query plan for approval. Use when analysis-log.md has no queries logged yet, or when the user says "investigate", "look into", or "analyze" something for the first time.
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash(npx @overscore/cli query run *)
 ---
 
 # Starting an analysis the right way
@@ -32,7 +37,7 @@ Ask these one or two at a time conversationally — don't dump all 6 at once lik
 
 ## After the interview
 
-1. **Read `.claude/rules/company-context.md`** to cross-reference what the user said against what's already documented about the project's data.
+1. **Read `.claude/knowledge/INDEX.md`** and any relevant knowledge files to understand what previous sessions have already documented about this project's data. Cross-reference what the user said against what's already known.
 2. **Draft an initial entry in `analysis-log.md`** with:
    - The clarified question (not the original title)
    - The tables the user named, with what each contains
@@ -51,4 +56,4 @@ Ask these one or two at a time conversationally — don't dump all 6 at once lik
 
 ## If the user resists the interview
 
-Some users will say "just look at the data, I'll tell you if it's wrong." That's a trap — you'll spend 30 minutes probing tables and still need the interview at the end. Push back once: "I can save us a lot of time if you tell me what tables matter and what success looks like — it's a 2-minute conversation." If they still refuse, do a single sizing pass on the parent project's known tables (from `company-context.md`), then come back and ask narrower questions based on what you found.
+Some users will say "just look at the data, I'll tell you if it's wrong." That's a trap — you'll spend 30 minutes probing tables and still need the interview at the end. Push back once: "I can save us a lot of time if you tell me what tables matter and what success looks like — it's a 2-minute conversation." If they still refuse, do a single sizing pass on the parent project's known tables (from the knowledge base), then come back and ask narrower questions based on what you found.

package/templates/analysis/_overscoreignore

@@ -0,0 +1,12 @@
+# Files matching these patterns are excluded from `analysis publish`.
+# Syntax: one pattern per line. `*` is a glob within a single path segment.
+# Trailing `/` matches a directory and everything inside it.
+# Lines starting with `#` are comments.
+#
+# A baseline set is always excluded regardless of this file:
+#   .git/, node_modules/, .DS_Store, .env*, .overscore/
+
+data/
+*.draft.html
+*.email.html
+.knowledge-hashes