flowseeker 0.1.7

package/dist/cli/runReplay.js

@@ -0,0 +1,481 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const loadConfigFromPath_1 = require("../config/loadConfigFromPath");
+const defaultConfig_1 = require("../config/defaultConfig");
+const evaluationMetrics_1 = require("../pipeline/evaluationMetrics");
+const feedback_1 = require("../pipeline/feedback");
+const fileGroups_1 = require("../pipeline/fileGroups");
+const runHeadless_1 = require("../pipeline/runHeadless");
+const tokenSavings_1 = require("../pipeline/tokenSavings");
+const text_1 = require("../utils/text");
+void main().catch((error) => {
+    const message = error instanceof Error ? error.stack ?? error.message : String(error);
+    console.error(message);
+    process.exitCode = 1;
+});
+async function main() {
+    const options = parseArgs(process.argv.slice(2));
+    const loaded = await loadReplayManifest(options);
+    const manifest = loaded.manifest;
+    validateManifest(manifest, loaded.source);
+    const startedAt = Date.now();
+    const results = [];
+    console.log(`FlowSeeker real-world replay: ${manifest.name ?? loaded.source}`);
+    console.log(`${loaded.kind}: ${loaded.source}`);
+    for (const workspace of manifest.workspaces) {
+        const workspacePath = path.resolve(workspace.path);
+        const workspaceName = workspace.name ?? path.basename(workspacePath);
+        const config = (0, defaultConfig_1.mergeConfig)(await (0, loadConfigFromPath_1.loadConfigFromPath)(workspacePath), workspace.config ?? {});
+        const cases = filterCases(await loadCases(workspacePath, workspace), options.caseId);
+        if (cases.length === 0) {
+            continue;
+        }
+        console.log(`\nWorkspace: ${workspaceName}`);
+        console.log(`Path: ${workspacePath}`);
+        console.log(`Cases: ${cases.length}`);
+        for (const caseDef of cases) {
+            const startedCaseAt = Date.now();
+            console.log(`- ${caseDef.id}: ${caseDef.task}`);
+            const result = await (0, runHeadless_1.runFlowSeekerHeadless)(workspacePath, caseDef.task, config, {
+                onProgress: options.verbose ? (message) => console.log(`  ${message}`) : undefined
+            });
+            const evaluated = evaluateCase(workspaceName, workspacePath, caseDef, result, Date.now() - startedCaseAt);
+            results.push(evaluated);
+            console.log(`  ${formatCaseConsole(evaluated)}`);
+        }
+    }
+    if (options.caseId && results.length === 0) {
+        throw new Error(`No replay case matched --case-id '${options.caseId}'.`);
+    }
+    const reportPath = path.resolve(options.reportPath ?? manifest.reportPath ?? defaultReportPath());
+    await fs.mkdir(path.dirname(reportPath), { recursive: true });
+    await fs.writeFile(reportPath, renderReport(manifest, results, Date.now() - startedAt), "utf8");
+    console.log(`\nReport: ${reportPath}`);
+    console.log(formatSummary(results));
+    console.log(formatTokenSavingsSummary(results));
+    if (options.failOnMiss && results.some((result) => result.pass === false)) {
+        process.exitCode = 1;
+    }
+    if (options.failOnGap && results.some((result) => result.contextGapReported)) {
+        process.exitCode = 1;
+    }
+}
+function parseArgs(args) {
+    const options = {
+        failOnGap: false,
+        failOnMiss: false,
+        verbose: false
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--manifest" || arg === "-m") {
+            options.manifestPath = requireValue(args, index, arg);
+            index += 1;
+            continue;
+        }
+        if (arg === "--workspace" || arg === "-w") {
+            options.workspacePath = requireValue(args, index, arg);
+            index += 1;
+            continue;
+        }
+        if (arg === "--name") {
+            options.workspaceName = requireValue(args, index, arg);
+            index += 1;
+            continue;
+        }
+        if (arg === "--task" || arg === "-t") {
+            options.task = requireValue(args, index, arg);
+            index += 1;
+            continue;
+        }
+        if (arg === "--case-id") {
+            options.caseId = requireValue(args, index, arg);
+            index += 1;
+            continue;
+        }
+        if (arg === "--feedback-dir") {
+            options.feedbackDir = requireValue(args, index, arg);
+            index += 1;
+            continue;
+        }
+        if (arg === "--report" || arg === "-r") {
+            options.reportPath = requireValue(args, index, arg);
+            index += 1;
+            continue;
+        }
+        if (arg === "--fail-on-gap") {
+            options.failOnGap = true;
+            continue;
+        }
+        if (arg === "--fail-on-miss") {
+            options.failOnMiss = true;
+            continue;
+        }
+        if (arg === "--verbose" || arg === "-v") {
+            options.verbose = true;
+            continue;
+        }
+        if (arg === "--help" || arg === "-h") {
+            printUsage();
+            process.exit(0);
+        }
+        throw new Error(`Unknown argument: ${arg}`);
+    }
+    return options;
+}
+async function loadReplayManifest(options) {
+    if (options.workspacePath) {
+        const workspacePath = path.resolve(options.workspacePath);
+        if (options.task?.trim()) {
+            return {
+                source: workspacePath,
+                kind: "Ad-hoc workspace",
+                manifest: {
+                    name: `Ad-hoc replay: ${options.workspaceName ?? path.basename(workspacePath)}`,
+                    reportPath: options.reportPath,
+                    workspaces: [
+                        {
+                            name: options.workspaceName ?? path.basename(workspacePath),
+                            path: workspacePath,
+                            cases: [
+                                {
+                                    id: options.caseId ?? slugify(options.task),
+                                    task: options.task.trim(),
+                                    source: "cli"
+                                }
+                            ]
+                        }
+                    ]
+                }
+            };
+        }
+        return {
+            source: options.feedbackDir ? path.resolve(options.feedbackDir) : workspacePath,
+            kind: "Feedback workspace",
+            manifest: {
+                name: `Feedback replay: ${options.workspaceName ?? path.basename(workspacePath)}`,
+                reportPath: options.reportPath,
+                workspaces: [
+                    {
+                        name: options.workspaceName ?? path.basename(workspacePath),
+                        path: workspacePath,
+                        includeFeedback: true,
+                        feedbackDir: options.feedbackDir
+                    }
+                ]
+            }
+        };
+    }
+    const manifestPath = path.resolve(options.manifestPath ?? path.join(".flowseeker", "replay-workspaces.json"));
+    return {
+        source: manifestPath,
+        kind: "Manifest",
+        manifest: await readJson(manifestPath)
+    };
+}
+async function loadCases(workspacePath, workspace) {
+    const cases = [...(workspace.cases ?? [])];
+    const shouldLoadFeedback = workspace.includeFeedback === true || cases.length === 0;
+    if (shouldLoadFeedback) {
+        const feedbackDir = workspace.feedbackDir ? resolveMaybeRelative(workspacePath, workspace.feedbackDir) : undefined;
+        const feedbackRecords = await (0, feedback_1.readFeedbackRecords)(workspacePath, feedbackDir);
+        cases.push(...feedbackRecords.map(({ record }) => replayCaseFromFeedback(record)));
+    }
+    return dedupeCases(cases).sort((left, right) => (left.createdAt ?? "").localeCompare(right.createdAt ?? "") || left.id.localeCompare(right.id));
+}
+function replayCaseFromFeedback(record) {
+    return {
+        id: `feedback-${record.id}`,
+        task: record.run.task,
+        createdAt: record.createdAt,
+        source: record.source,
+        notes: record.note,
+        feedbackKind: record.kind,
+        feedbackNote: record.note,
+        expectedPaths: record.labels?.expectedPaths,
+        avoidPaths: record.labels?.avoidPaths,
+        passAtK: record.labels?.passAtK,
+        expectedMode: record.labels?.expectedMode,
+        originalTopFiles: record.run.topFiles?.map((f) => ({
+            relativePath: f.relativePath,
+            role: f.role,
+            score: f.score,
+            evidence: f.evidence
+        })),
+        outcome: record.outcome
+    };
+}
+function filterCases(cases, caseId) {
+    if (!caseId) {
+        return cases;
+    }
+    return cases.filter((caseDef) => caseDef.id === caseId);
+}
+function evaluateCase(workspaceName, workspacePath, caseDef, result, durationMs) {
+    const passAtK = caseDef.passAtK ?? 10;
+    const expectedMetrics = (0, evaluationMetrics_1.computeExpectedPathMetrics)(result.units, caseDef.expectedPaths ?? [], passAtK, caseDef.expectedMode ?? "any");
+    const avoidHitsTop10 = findAvoidHits(result.units.slice(0, 10), caseDef.avoidPaths ?? []);
+    const contextGapReported = caseDef.feedbackKind === "missing_file" || caseDef.feedbackKind === "agent_needed_more_context" || caseDef.outcome?.aiNeededMoreContext === true;
+    const positiveFeedback = caseDef.feedbackKind === "relevant" || caseDef.outcome?.planAccepted === true || caseDef.outcome?.fixVerified === true;
+    const negativeFeedback = caseDef.feedbackKind === "not_relevant" || contextGapReported;
+    return {
+        workspaceName,
+        workspacePath,
+        caseDef,
+        result,
+        durationMs,
+        expectedMetrics,
+        pass: expectedMetrics.pass,
+        avoidHitsTop10,
+        contextGapReported,
+        positiveFeedback,
+        negativeFeedback
+    };
+}
+function findAvoidHits(units, avoidPaths) {
+    if (avoidPaths.length === 0) {
+        return [];
+    }
+    return uniqueStrings(units
+        .filter((unit) => avoidPaths.some((avoidPath) => (0, evaluationMetrics_1.pathMatches)(unit.relativePath, avoidPath)))
+        .filter((unit) => !unit.contrastContext)
+        .map((unit) => unit.relativePath));
+}
+function renderReport(manifest, results, durationMs) {
+    const lines = [
+        "# FlowSeeker Real-World Replay Report",
+        "",
+        `Generated: ${new Date().toISOString()}`,
+        `Replay: ${manifest.name ?? "Unnamed replay"}`,
+        `Workspaces: ${new Set(results.map((result) => result.workspaceName)).size}`,
+        `Cases: ${results.length}`,
+        `Duration: ${(durationMs / 1000).toFixed(2)}s`,
+        "",
+        "## Summary",
+        "",
+        formatSummary(results),
+        formatTokenSavingsSummary(results),
+        "",
+        "## How To Read This",
+        "",
+        "- `Context gap reported` comes from human/agent feedback, not from FlowSeeker guessing.",
+        "- `Expected pass` is only available when a case has expected paths.",
+        "- Token savings are measured with the same local tokenizer/baseline used by FlowSeeker packets.",
+        "",
+        "## Workspace Summary",
+        "",
+        ...renderWorkspaceSummary(results),
+        "",
+        "## Cases",
+        ""
+    ];
+    for (const result of results) {
+        lines.push(...renderCase(result));
+    }
+    return `${lines.join("\n")}\n`;
+}
+function renderWorkspaceSummary(results) {
+    const byWorkspace = new Map();
+    for (const result of results) {
+        byWorkspace.set(result.workspaceName, [...(byWorkspace.get(result.workspaceName) ?? []), result]);
+    }
+    return Array.from(byWorkspace.entries()).map(([workspaceName, workspaceResults]) => `- ${workspaceName}: ${formatSummary(workspaceResults)}; ${formatTokenSavingsSummary(workspaceResults)}`);
+}
+function renderCase(result) {
+    const status = result.pass === "unlabeled" ? "UNLABELED" : result.pass ? "PASS" : "FAIL";
+    const topFiles = (0, fileGroups_1.aggregateEvidenceFiles)(result.result.units).slice(0, 15);
+    const stats = result.result.stats;
+    return [
+        `### ${status} - ${result.workspaceName}/${result.caseDef.id}`,
+        "",
+        `Workspace: ${result.workspacePath}`,
+        `Task: ${result.caseDef.task}`,
+        ...(result.caseDef.createdAt ? [`Original feedback/task time: ${result.caseDef.createdAt}`] : []),
+        ...(result.caseDef.source ? [`Source: ${result.caseDef.source}`] : []),
+        ...(result.caseDef.notes ? [`Notes: ${result.caseDef.notes}`] : []),
+        ...(result.caseDef.feedbackKind ? [`Feedback: ${result.caseDef.feedbackKind}${result.caseDef.feedbackNote ? ` - ${result.caseDef.feedbackNote}` : ""}`] : []),
+        `Context gap reported: ${yesNo(result.contextGapReported)}`,
+        `Positive feedback: ${yesNo(result.positiveFeedback)}`,
+        `Intent: ${result.result.profile.intent}`,
+        `Keywords: ${result.result.profile.keywords.join(", ") || "none"}`,
+        `Expected paths: ${(result.caseDef.expectedPaths ?? []).join(", ") || "none"}`,
+        `Expected mode: ${result.caseDef.expectedMode ?? "any"}`,
+        `Coverage@5/10/20/40: ${result.expectedMetrics.coverageAt5}/${result.expectedMetrics.expectedCount}, ${result.expectedMetrics.coverageAt10}/${result.expectedMetrics.expectedCount}, ${result.expectedMetrics.coverageAt20}/${result.expectedMetrics.expectedCount}, ${result.expectedMetrics.coverageAt40}/${result.expectedMetrics.expectedCount}`,
+        `Missing expected at 10: ${result.expectedMetrics.missingAt10.join(", ") || "none"}`,
+        `Avoid hits in top 10: ${result.avoidHitsTop10.join(", ") || "none"}`,
+        `Token savings: ${formatCaseTokenSavings(result)}`,
+        `Context coverage: ${formatContextCoverage(result.result)}`,
+        `Duration: ${(result.durationMs / 1000).toFixed(2)}s`,
+        `Scan: discovered=${stats.discoveredFiles}, scanned=${stats.scannedFiles}, skipped=${stats.skippedFiles}, rawEvidence=${stats.rawEvidenceCount}, ranked=${stats.rankedEvidenceCount}, capped=${stats.capped}, stoppedEarly=${stats.stoppedEarly}${stats.stopReason ? ` (${stats.stopReason})` : ""}`,
+        "",
+        "Top files:",
+        "",
+        ...topFiles.map((group, index) => `${index + 1}. ${group.relativePath} [${group.role}/${group.slot}] score=${group.score.toFixed(1)} evidence=${group.unitCount} subsystem=${group.subsystem ?? "none"}`),
+        ...(result.caseDef.originalTopFiles && result.caseDef.originalTopFiles.length > 0
+            ? [
+                "",
+                "Original top files (from feedback snapshot):",
+                "",
+                ...result.caseDef.originalTopFiles.map((f, index) => `${index + 1}. ${f.relativePath} [${f.role}] score=${f.score.toFixed(1)} evidence=${f.evidence}`)
+            ]
+            : []),
+        ""
+    ];
+}
+function formatSummary(results) {
+    const labeled = results.filter((result) => result.pass !== "unlabeled");
+    const passed = labeled.filter((result) => result.pass === true);
+    const feedbackCases = results.filter((result) => result.caseDef.feedbackKind || result.caseDef.outcome);
+    const positive = feedbackCases.filter((result) => result.positiveFeedback).length;
+    const negative = feedbackCases.filter((result) => result.negativeFeedback).length;
+    const contextGaps = feedbackCases.filter((result) => result.contextGapReported).length;
+    const avoidCases = results.filter((result) => (result.caseDef.avoidPaths ?? []).length > 0).length;
+    const avoidHitCases = results.filter((result) => result.avoidHitsTop10.length > 0).length;
+    const avgRequiredCoverage = average(results.map((result) => result.result.contextCoverage?.requiredCoveragePercent ?? 0));
+    const avgDuration = average(results.map((result) => result.durationMs));
+    return `cases=${results.length}, labeled=${labeled.length}, expectedPass=${passed.length}/${labeled.length}, feedbackCases=${feedbackCases.length}, positiveFeedback=${positive}/${feedbackCases.length}, negativeFeedback=${negative}/${feedbackCases.length}, contextGapReported=${contextGaps}/${feedbackCases.length}, avoidHitCases=${avoidHitCases}/${avoidCases}, requiredCoverageAvg=${avgRequiredCoverage.toFixed(1)}%, avg=${(avgDuration / 1000).toFixed(2)}s`;
+}
+function formatTokenSavingsSummary(results) {
+    const metrics = results.map((result) => result.result.tokenSavings).filter((item) => item !== undefined && item.status !== "unavailable");
+    if (metrics.length === 0) {
+        return "tokenSavings=unavailable";
+    }
+    const avgReduction = average(metrics.map((item) => item.reductionPercent));
+    const avgPacketTokens = average(metrics.map((item) => item.solvePacketTokensEstimate));
+    const avgWorkspaceTokens = average(metrics.map((item) => item.workspaceTokensEstimate));
+    const partial = metrics.filter((item) => item.status === "partial").length;
+    const proofPartial = metrics.filter((item) => item.proofStatus !== "complete").length;
+    return `tokenSavings avg=${(0, tokenSavings_1.formatReductionPercent)(avgReduction)}, packetAvg=${(0, tokenSavings_1.formatTokenCount)(avgPacketTokens)}, workspaceAvg=${(0, tokenSavings_1.formatTokenCount)(avgWorkspaceTokens)}, partial=${partial}/${metrics.length}, proofNotComplete=${proofPartial}/${metrics.length}`;
+}
+function formatCaseConsole(result) {
+    const status = result.pass === "unlabeled" ? "UNLABELED" : result.pass ? "PASS" : "FAIL";
+    const gap = result.contextGapReported ? "context gap reported" : "no reported gap";
+    return `${status}; ${gap}; ${formatCaseTokenSavings(result)}; ${formatContextCoverage(result.result)}; ${(result.durationMs / 1000).toFixed(2)}s`;
+}
+function formatCaseTokenSavings(result) {
+    const metrics = result.result.tokenSavings;
+    if (!metrics || metrics.status === "unavailable") {
+        return "tokens unavailable";
+    }
+    const warning = metrics.proofWarnings.length > 0 ? `; warnings=${metrics.proofWarnings.join(" | ")}` : "";
+    return `tokens ${(0, tokenSavings_1.formatTokenCount)(metrics.solvePacketTokensEstimate)}/${(0, tokenSavings_1.formatTokenCount)(metrics.workspaceTokensEstimate)} saved=${(0, tokenSavings_1.formatReductionPercent)(metrics.reductionPercent)} tokenizer=${metrics.tokenizer} proof=${metrics.proofStatus}${warning}`;
+}
+function formatContextCoverage(result) {
+    const coverage = result.contextCoverage;
+    if (!coverage) {
+        return "coverage unavailable";
+    }
+    const missing = coverage.missingRequiredSlots.length > 0 ? ` missing=${coverage.missingRequiredSlots.join("|")}` : "";
+    return `coverage ${coverage.foundRequiredSlots.length}/${coverage.requiredSlots.length} (${coverage.requiredCoveragePercent.toFixed(0)}%)${missing}`;
+}
+function validateManifest(manifest, manifestPath) {
+    if (!Array.isArray(manifest.workspaces) || manifest.workspaces.length === 0) {
+        throw new Error(`Invalid replay manifest ${manifestPath}: workspaces must be a non-empty array.`);
+    }
+    manifest.workspaces.forEach((workspace, index) => {
+        if (!workspace.path) {
+            throw new Error(`Invalid replay manifest ${manifestPath}: workspaces[${index}].path is required.`);
+        }
+    });
+}
+async function readJson(filePath) {
+    const text = await fs.readFile(filePath, "utf8");
+    return JSON.parse(text);
+}
+function dedupeCases(cases) {
+    const byKey = new Map();
+    for (const caseDef of cases) {
+        const key = caseDef.id || slugify(caseDef.task);
+        byKey.set(key, { ...caseDef, id: key });
+    }
+    return Array.from(byKey.values());
+}
+function resolveMaybeRelative(workspacePath, value) {
+    return path.isAbsolute(value) ? value : path.resolve(workspacePath, value);
+}
+function requireValue(args, index, flag) {
+    const value = args[index + 1];
+    if (!value || value.startsWith("-")) {
+        throw new Error(`${flag} requires a value.`);
+    }
+    return value.replace(/\^/g, "");
+}
+function slugify(value) {
+    const slug = (0, text_1.normalizeText)(value)
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 72);
+    return slug || "replay-task";
+}
+function printUsage() {
+    console.log([
+        "Usage:",
+        "  node dist/cli/runReplay.js --manifest .flowseeker/replay-workspaces.json",
+        "  node dist/cli/runReplay.js --workspace D:/repo",
+        "  node dist/cli/runReplay.js --workspace D:/repo --task \"Fix timestamp based on browser timezone\"",
+        "",
+        "Options:",
+        "  --manifest, -m       Path to a real-world replay manifest.",
+        "  --workspace, -w      Run one workspace. Without --task, loads .flowseeker/feedback.",
+        "  --task, -t           Natural-language task for ad-hoc replay mode.",
+        "  --feedback-dir       Override feedback directory for workspace replay.",
+        "  --case-id            Filter to one replay case id.",
+        "  --report, -r         Override report output path.",
+        "  --fail-on-gap        Exit with code 1 if feedback reports missing context.",
+        "  --fail-on-miss       Exit with code 1 if labeled expected paths miss pass@K.",
+        "  --verbose, -v        Print scan progress.",
+        ""
+    ].join("\n"));
+}
+function defaultReportPath() {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    return path.join(".flowseeker", "reports", `real-world-replay-${timestamp}.md`);
+}
+function yesNo(value) {
+    return value ? "yes" : "no";
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values));
+}
+function average(values) {
+    if (values.length === 0) {
+        return 0;
+    }
+    return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+//# sourceMappingURL=runReplay.js.map

package/dist/commands/checkHostCompatibility.js

@@ -0,0 +1,149 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkHostCompatibility = checkHostCompatibility;
+const vscode = __importStar(require("vscode"));
+const approvalPolicy_1 = require("../agent/approvalPolicy");
+const capabilities_1 = require("../runtime/capabilities");
+const hostDetect_1 = require("../runtime/hostDetect");
+const hostTier_1 = require("../runtime/hostTier");
+const mcpConfig_1 = require("../mcp/mcpConfig");
+async function checkHostCompatibility(context) {
+    const host = (0, hostDetect_1.detectHost)();
+    const capabilities = (0, capabilities_1.getHostCapabilities)(context);
+    const probe = await (0, hostDetect_1.probeLanguageModels)(capabilities);
+    const tier = (0, hostTier_1.getHostTier)();
+    const mcpServers = await (0, mcpConfig_1.loadMcpServerConfigs)();
+    const policy = (0, approvalPolicy_1.getApprovalPolicy)();
+    const existingVerification = (0, hostTier_1.getVerificationForHost)(context, host.id, host.version);
+    const lines = [
+        "# FlowSeeker Host Compatibility",
+        "",
+        "## Host Identity",
+        "",
+        ...(0, hostDetect_1.summarizeProbe)(host, capabilities, probe).map((line) => `- ${line}`),
+        "",
+        "## Tier",
+        "",
+        `- **Tier:** ${(0, hostTier_1.tierLabel)(tier.tier)}`,
+        `- **Description:** ${(0, hostTier_1.tierDescription)(tier.tier)}`,
+        `- **Reason:** ${tier.reason}`,
+        "",
+        ...(existingVerification
+            ? [
+                `- **User verified:** ${existingVerification.nativeChatWorks ? "Native Chat works on this host" : "Native Chat does NOT work on this host"}`,
+                `- **Verified at:** ${existingVerification.verifiedAt}`,
+                ...(existingVerification.notes ? [`- **Notes:** ${existingVerification.notes}`] : []),
+                ""
+            ]
+            : tier.tier === "native-unverified"
+                ? [
+                    "",
+                    "> **Can you help verify?** Open your host's chat panel and type `@flowseeker /guide test`. Does the FlowSeeker participant appear and respond?",
+                    ""
+                ]
+                : [""]),
+        "## Capabilities",
+        "",
+        ...(0, capabilities_1.summarizeHostCapabilities)(capabilities).map((line) => `- ${line}`),
+        "",
+        "## MCP Configuration",
+        "",
+        mcpServers.length > 0
+            ? `FlowSeeker found ${mcpServers.length} configured MCP server(s):`
+            : "FlowSeeker did not find any configured MCP servers.",
+        "",
+        ...mcpServers.map((server) => `- ${server.enabled === false ? "[disabled] " : ""}${server.name} (${server.type})`),
+        "",
+        "## Agent Approval Policy",
+        "",
+        `- Read workspace: ${enabled(policy.readWorkspace)}`,
+        `- Edit workspace: ${enabled(policy.editWorkspace)}`,
+        `- Safe commands: ${enabled(policy.safeCommands)}`,
+        `- All commands: ${enabled(policy.allCommands)}`,
+        `- MCP tools: ${enabled(policy.mcpTools)}`,
+        `- Rules: ${policy.rules.length}`,
+        "",
+        "## Recommended Fallbacks",
+        "",
+        ...tierFallbacks(tier.tier)
+    ];
+    const document = await vscode.workspace.openTextDocument({
+        content: lines.join("\n"),
+        language: "markdown"
+    });
+    await vscode.window.showTextDocument(document, { preview: false });
+    // Human-in-the-loop verification for unverified hosts
+    if (tier.tier === "native-unverified" && !existingVerification) {
+        const answer = await vscode.window.showInformationMessage(`FlowSeeker detected "${host.appName}" — a host that may support Native Chat but hasn't been verified. Does @flowseeker /guide work in your chat panel?`, { modal: false }, "Yes, it works", "No, it doesn't", "Skip");
+        if (answer === "Yes, it works" || answer === "No, it doesn't") {
+            (0, hostTier_1.saveHostVerification)(context, {
+                hostId: host.id,
+                hostVersion: host.version,
+                nativeChatWorks: answer === "Yes, it works",
+                verifiedAt: new Date().toISOString()
+            });
+        }
+    }
+}
+function tierFallbacks(tier) {
+    switch (tier) {
+        case "native-full":
+            return [
+                "- Native Chat is your primary interface. Sidebar is available as a secondary option.",
+                "- If Native Chat is ever unavailable, the sidebar chat and Copy Agent Prompt will still work."
+            ];
+        case "native-unverified":
+            return [
+                "- **Primary (guaranteed):** Use the FlowSeeker sidebar chat for all commands.",
+                "- **Copy Agent Prompt:** Copy context and paste into Cursor Composer, Antigravity Agent, or any AI tool.",
+                "- **Native Chat:** May work — try `@flowseeker /guide` in your host's chat panel.",
+                "- If Language Model API returns 0 models, configure a direct provider key in the sidebar."
+            ];
+        case "sidebar-primary":
+            return [
+                "- **Primary:** Use the FlowSeeker sidebar chat.",
+                "- **Copy Agent Prompt:** Copy the Solve Packet and paste into any AI tool.",
+                "- **Direct Provider:** Configure an API key (OpenAI, Anthropic, Gemini, etc.) for AI-assisted guidance.",
+                "- Native Chat is not available on this host."
+            ];
+        default:
+            return [];
+    }
+}
+function enabled(value) {
+    return value ? "auto-approved" : "requires approval";
+}
+//# sourceMappingURL=checkHostCompatibility.js.map

package/dist/commands/copyAgentPrompt.js

@@ -0,0 +1,52 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyAgentPrompt = copyAgentPrompt;
+const vscode = __importStar(require("vscode"));
+const agentPrompt_1 = require("../pipeline/agentPrompt");
+const logger_1 = require("../utils/logger");
+async function copyAgentPrompt(provider) {
+    const result = provider.getResult();
+    if (!result) {
+        vscode.window.showWarningMessage("Run FlowSeeker: Find Relevant Context first.");
+        return;
+    }
+    const selectedUnits = provider.getSelectedUnits();
+    const prompt = (0, agentPrompt_1.createAgentSolvePrompt)(result, selectedUnits);
+    await vscode.env.clipboard.writeText(prompt);
+    (0, logger_1.logInfo)(`Copied agent solve prompt with ${selectedUnits.length} selected evidence units.`);
+    vscode.window.showInformationMessage("Copied FlowSeeker agent solve prompt.");
+}
+//# sourceMappingURL=copyAgentPrompt.js.map