@longtable/cli 0.1.29 → 0.1.30

package/README.md

@@ -200,11 +200,18 @@ deduplicates, ranks, and labels results as evidence cards. Some sources work
 without keys, some require a contact email, and some need API keys for reliable
 use.
 
+Publisher access is configured separately through environment variables and
+DOI probes. `longtable search setup` checks Elsevier, Springer Nature, Wiley,
+and Taylor & Francis credentials or TDM tokens without storing secrets.
+
 Citation support should be checked explicitly. A reference can be useful as
 background while still failing to support the specific claim attached to it.
 
 ```bash
+longtable search setup
+longtable search probe --doi "10.1016/example" --publisher elsevier
 longtable search --query "trust calibration measurement" --intent measurement
+longtable search --query "trust calibration measurement" --publisher-access --json
 longtable search --query "trust calibration citation support" --intent citation --record
 ```
 

package/dist/cli.js

@@ -8,7 +8,7 @@ import { stdin as input, stdout as output, cwd, env, exit } from "node:process";
 import { dirname, join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { classifyCheckpointTrigger } from "@longtable/checkpoints";
-import { assessSearchSourceCapabilities, buildResearchSearchIntent, runResearchSearch } from "./search/index.js";
+import { assessSearchSourceCapabilities, buildResearchSearchIntent, buildSearchCapabilitySnapshot, parsePublisherTarget, probePublisherAccess, publisherConfigs, runResearchSearch, searchCapabilitySnapshotPath, summarizeConfiguredPublisherAccess } from "./search/index.js";
 import { buildProviderChoices, buildQuickSetupFlow, createPersistedSetupOutput, installRuntimeConfigFromStoredSetup, loadSetupOutput, renderInstallSummary, renderSetupSummary, resolveDefaultRuntimeConfigPath, resolveDefaultSetupPath, saveSetupOutput, saveSetupAndRuntimeConfig, serializeSetupOutput, writeRuntimeConfig } from "@longtable/setup";
 import { buildCodexSkillSpecs, buildCodexThinWrappedPrompt, installCodexSkills, listInstalledCodexSkills, renderQuestionRecordPrompt, removeCodexSkills, resolveCodexSkillsDir, runCodexThinWrapper } from "@longtable/provider-codex";
 import { buildClaudeSkillSpecs, installClaudeSkills, listInstalledClaudeSkills, renderQuestionRecordInput, removeClaudeSkills, resolveClaudeSkillsDir } from "@longtable/provider-claude";
@@ -43,7 +43,7 @@ const ANSI = {
     green: "\u001B[32m"
 };
 const LONGTABLE_MCP_SERVER_NAME = "longtable-state";
-const LONGTABLE_MCP_PACKAGE_VERSION = "0.1.29";
+const LONGTABLE_MCP_PACKAGE_VERSION = "0.1.30";
 const LONGTABLE_MCP_MARKER_START = "# LongTable state MCP START";
 const LONGTABLE_MCP_MARKER_END = "# LongTable state MCP END";
 function style(text, prefix) {
@@ -89,7 +89,10 @@ function usage() {
         "  longtable show [--json] [--path <file>]",
         "  longtable install [--json] [--path <file>] [--runtime-path <file>]",
         "  longtable mcp install [--provider codex|claude|all] [--write] [--checkpoint-ui off|interactive|strong] [--json] [--codex-config <path>] [--claude-settings <path>] [--package <spec>]",
-        "  longtable search --query <text> [--intent literature|theory|measurement|citation|metadata|venue] [--field <text>] [--source all|crossref,arxiv,openalex,semantic_scholar,pubmed,eric,doaj,unpaywall] [--must <term[,term]>] [--exclude <term[,term]>] [--limit <n>] [--allow-partial] [--record] [--cwd <path>] [--json]",
+        "  longtable search --query <text> [--intent literature|theory|measurement|citation|metadata|venue] [--field <text>] [--source all|crossref,arxiv,openalex,semantic_scholar,pubmed,eric,doaj,unpaywall] [--must <term[,term]>] [--exclude <term[,term]>] [--limit <n>] [--allow-partial] [--publisher-access] [--record] [--cwd <path>] [--json]",
+        "  longtable search setup [--doi <doi>] [--json]",
+        "  longtable search doctor [--doi <doi>] [--publisher auto|elsevier|springer_nature|wiley|taylor_francis|all] [--json]",
+        "  longtable search probe --doi <doi> [--publisher auto|elsevier|springer_nature|wiley|taylor_francis] [--json]",
         "  longtable sentinel --prompt <text> [--cwd <path>] [--json] [--record]",
         "  longtable team --prompt <text> [--role <role[,role]>] [--debate] [--rounds 3|5] [--cwd <path>] [--json]",
         "  longtable ask [--prompt <text>] [--print] [--json] [--setup <path>] [--cwd <path>]",
@@ -136,6 +139,10 @@ function parseArgs(argv) {
     else if (command === "codex" || command === "claude" || command === "mcp") {
         startIndex = 2;
     }
+    else if (command === "search" && maybeSubcommand && !maybeSubcommand.startsWith("--")) {
+        subcommand = maybeSubcommand;
+        startIndex = 2;
+    }
     else if (directCommand) {
         subcommand = undefined;
         startIndex = 1;
@@ -2013,6 +2020,7 @@ function renderEvidenceRunSummary(run, recordedPath) {
         ].filter(Boolean).join(", ");
         lines.push(`  - ${card.title}`);
         lines.push(`    score: ${card.relevanceScore}; support: ${card.citationSupportStatus}; depth: ${card.evidenceDepth}; sources: ${card.sourceRoutes.join(", ")}`);
+        lines.push(`    access: ${card.accessStatus}; verification: ${card.verificationNote}`);
         if (identifiers) {
             lines.push(`    ids: ${identifiers}`);
         }
@@ -2056,7 +2064,194 @@ async function recordEvidenceRun(run, workingDirectory) {
     await syncCurrentWorkspaceView(context);
     return evidencePath;
 }
-async function runSearch(args) {
+function renderPublisherAccessRecord(record) {
+    const envSummary = record.missingEnv.length > 0
+        ? `missing ${record.missingEnv.join(", ")}`
+        : `configured ${record.presentEnv.join(", ") || "none"}`;
+    const lines = [
+        `${record.publisher}:`,
+        `  credential: ${record.credentialStatus} (${envSummary})`,
+        `  entitlement: ${record.entitlementStatus}; tdm: ${record.tdmStatus}; depth: ${record.collectionDepth}`,
+        `  verification: ${record.verificationNote}`
+    ];
+    if (record.testedDoi) {
+        lines.push(`  tested doi: ${record.testedDoi}`);
+    }
+    if (record.endpoint) {
+        lines.push(`  endpoint: ${record.endpoint}`);
+    }
+    if (record.licenseNote) {
+        lines.push(`  license: ${record.licenseNote}`);
+    }
+    if (record.setupHint) {
+        lines.push(`  setup: ${record.setupHint}`);
+    }
+    return lines.join("\n");
+}
+function renderPublisherAccessRecords(title, records, capabilityPath) {
+    const lines = [title];
+    if (capabilityPath) {
+        lines.push(`- capability file: ${capabilityPath}`);
+    }
+    for (const record of records) {
+        lines.push(renderPublisherAccessRecord(record));
+    }
+    return lines.join("\n");
+}
+async function saveSearchCapabilityRecords(records) {
+    const snapshotPath = searchCapabilitySnapshotPath();
+    await mkdir(dirname(snapshotPath), { recursive: true });
+    await writeJsonFile(snapshotPath, buildSearchCapabilitySnapshot(records, env));
+    return snapshotPath;
+}
+async function probeAllPublishers(doi) {
+    const records = [];
+    for (const publisher of publisherConfigs()) {
+        records.push(await probePublisherAccess({
+            doi,
+            publisher: publisher.publisher,
+            env
+        }));
+    }
+    return records;
+}
+async function runSearchProbe(args) {
+    if (typeof args.doi !== "string" || !args.doi.trim()) {
+        throw new Error("`longtable search probe` requires --doi <doi>.");
+    }
+    const publisher = parsePublisherTarget(args.publisher);
+    const record = await probePublisherAccess({
+        doi: args.doi,
+        publisher,
+        env
+    });
+    if (args.json === true) {
+        console.log(JSON.stringify({ record }, null, 2));
+    }
+    else {
+        console.log(renderPublisherAccessRecord(record));
+    }
+    return [record];
+}
+async function runSearchDoctor(args) {
+    let records;
+    if (typeof args.doi === "string" && args.doi.trim()) {
+        if (args.publisher === "all") {
+            records = await probeAllPublishers(args.doi);
+        }
+        else {
+            const publisher = parsePublisherTarget(args.publisher);
+            records = [await probePublisherAccess({
+                    doi: args.doi,
+                    publisher,
+                    env
+                })];
+        }
+    }
+    else {
+        records = summarizeConfiguredPublisherAccess(env);
+    }
+    const snapshotPath = searchCapabilitySnapshotPath();
+    const snapshotExists = existsSync(snapshotPath);
+    if (args.json === true) {
+        console.log(JSON.stringify({
+            capabilityFile: snapshotPath,
+            capabilityFileExists: snapshotExists,
+            records
+        }, null, 2));
+    }
+    else {
+        console.log(renderPublisherAccessRecords("LongTable Search Publisher Access Doctor", records, snapshotPath));
+        if (!snapshotExists) {
+            console.log("- saved capabilities: none yet; run `longtable search setup` to record non-secret capability status.");
+        }
+    }
+    return records;
+}
+async function promptPublisherDoi(rl, label, defaultDoi) {
+    const prompt = defaultDoi
+        ? `${label} test DOI [${defaultDoi}, Enter to reuse, skip to skip]: `
+        : `${label} test DOI (Enter to skip): `;
+    const answer = (await rl.question(prompt)).trim();
+    if (!answer && defaultDoi) {
+        return defaultDoi;
+    }
+    if (!answer || /^skip$/i.test(answer)) {
+        return undefined;
+    }
+    return answer;
+}
+async function runInteractiveSearchSetup(defaultDoi) {
+    const rl = createInterface({ input, output });
+    const records = [];
+    try {
+        console.log("LongTable publisher access setup");
+        console.log("LongTable does not store API keys or TDM tokens. It reads environment variables and records only non-secret capability results.");
+        console.log("");
+        for (const publisher of publisherConfigs()) {
+            console.log(`${publisher.label}`);
+            console.log(`  required env: ${publisher.requiredEnv.join(", ")}`);
+            if (publisher.optionalEnv.length > 0) {
+                console.log(`  optional env: ${publisher.optionalEnv.join(", ")}`);
+            }
+            console.log(`  ${publisher.setupHint}`);
+            const doi = await promptPublisherDoi(rl, publisher.label, defaultDoi);
+            if (doi) {
+                records.push(await probePublisherAccess({
+                    doi,
+                    publisher: publisher.publisher,
+                    env
+                }));
+            }
+            else {
+                const summary = summarizeConfiguredPublisherAccess(env)
+                    .find((record) => record.publisher === publisher.publisher);
+                if (summary) {
+                    records.push(summary);
+                }
+            }
+            console.log(renderPublisherAccessRecord(records[records.length - 1]));
+            console.log("");
+        }
+    }
+    finally {
+        rl.close();
+    }
+    return records;
+}
+async function runSearchSetup(args) {
+    const defaultDoi = typeof args.doi === "string" ? args.doi : undefined;
+    const records = input.isTTY && output.isTTY && args.json !== true
+        ? await runInteractiveSearchSetup(defaultDoi)
+        : defaultDoi
+            ? await probeAllPublishers(defaultDoi)
+            : summarizeConfiguredPublisherAccess(env);
+    const snapshotPath = await saveSearchCapabilityRecords(records);
+    if (args.json === true) {
+        console.log(JSON.stringify({
+            capabilityFile: snapshotPath,
+            snapshot: buildSearchCapabilitySnapshot(records, env)
+        }, null, 2));
+        return;
+    }
+    console.log(renderPublisherAccessRecords("LongTable Search Publisher Access Setup", records, snapshotPath));
+}
+async function runSearch(subcommand, args) {
+    if (subcommand === "probe") {
+        await runSearchProbe(args);
+        return;
+    }
+    if (subcommand === "doctor" || subcommand === "status") {
+        await runSearchDoctor(args);
+        return;
+    }
+    if (subcommand === "setup") {
+        await runSearchSetup(args);
+        return;
+    }
+    if (subcommand) {
+        throw new Error(`Unknown search subcommand: ${subcommand}`);
+    }
     const workingDirectory = typeof args.cwd === "string" ? args.cwd : cwd();
     const projectContext = await loadProjectContextFromDirectory(workingDirectory);
     const searchInput = {
@@ -2082,7 +2277,8 @@ async function runSearch(args) {
     const run = await runResearchSearch({
         ...searchInput,
         env,
-        allowPartial
+        allowPartial,
+        publisherAccess: args["publisher-access"] === true
     });
     let recordedPath;
     if (args.record === true && run.status !== "blocked") {
@@ -2907,7 +3103,7 @@ async function main() {
         return;
     }
     if (command === "search") {
-        await runSearch(values);
+        await runSearch(subcommand, values);
         return;
     }
     if (command === "ask") {

package/dist/search/index.d.ts

@@ -3,3 +3,4 @@ export * from "./query.js";
 export * from "./sources.js";
 export * from "./rank.js";
 export * from "./run.js";
+export * from "./publisher-access.js";

package/dist/search/index.js

@@ -3,3 +3,4 @@ export * from "./query.js";
 export * from "./sources.js";
 export * from "./rank.js";
 export * from "./run.js";
+export * from "./publisher-access.js";

package/dist/search/publisher-access.d.ts

@@ -0,0 +1,23 @@
+import { type CrossrefTdmDiscovery, type EvidenceCard, type Publisher, type PublisherAccessRecord, type PublisherProbeInput, type PublisherProbeTarget, type SearchCapabilitySnapshot, type SearchFetch } from "./types.js";
+interface PublisherConfig {
+    publisher: Publisher;
+    label: string;
+    requiredEnv: string[];
+    optionalEnv: string[];
+    setupHint: string;
+}
+export declare function normalizeDoi(value: string): string;
+export declare function parsePublisherTarget(value?: string | boolean): PublisherProbeTarget;
+export declare function discoverCrossrefTdm(doi: string, env?: Record<string, string | undefined>, httpFetch?: SearchFetch): Promise<CrossrefTdmDiscovery>;
+export declare function publisherConfigs(): PublisherConfig[];
+export declare function probePublisherAccess(input: PublisherProbeInput): Promise<PublisherAccessRecord>;
+export declare function summarizeConfiguredPublisherAccess(env?: Record<string, string | undefined>): PublisherAccessRecord[];
+export declare function buildSearchCapabilitySnapshot(records: PublisherAccessRecord[], env?: Record<string, string | undefined>): SearchCapabilitySnapshot;
+export declare function searchCapabilitySnapshotPath(home?: string): string;
+export declare function enrichCardsWithPublisherAccess(input: {
+    cards: EvidenceCard[];
+    env?: Record<string, string | undefined>;
+    fetch?: SearchFetch;
+    limit?: number;
+}): Promise<EvidenceCard[]>;
+export {};

package/dist/search/publisher-access.js

@@ -0,0 +1,577 @@
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { PUBLISHERS } from "./types.js";
+const PUBLISHER_CONFIGS = {
+    elsevier: {
+        publisher: "elsevier",
+        label: "Elsevier / ScienceDirect",
+        requiredEnv: ["ELSEVIER_API_KEY"],
+        optionalEnv: ["ELSEVIER_INST_TOKEN", "ELSEVIER_AUTHTOKEN"],
+        setupHint: "Set ELSEVIER_API_KEY and, when your institution provides one, ELSEVIER_INST_TOKEN or ELSEVIER_AUTHTOKEN."
+    },
+    springer_nature: {
+        publisher: "springer_nature",
+        label: "Springer Nature",
+        requiredEnv: ["SPRINGER_NATURE_API_KEY"],
+        optionalEnv: ["SPRINGER_NATURE_TDM_API_KEY", "SPRINGER_NATURE_TDM_ENDPOINT"],
+        setupHint: "Set SPRINGER_NATURE_API_KEY. Add SPRINGER_NATURE_TDM_ENDPOINT when your TDM agreement provides a licensed full-text endpoint."
+    },
+    wiley: {
+        publisher: "wiley",
+        label: "Wiley",
+        requiredEnv: ["WILEY_TDM_TOKEN"],
+        optionalEnv: ["WILEY_TDM_CLIENT_TOKEN"],
+        setupHint: "Set WILEY_TDM_TOKEN or WILEY_TDM_CLIENT_TOKEN after accepting Wiley's TDM terms."
+    },
+    taylor_francis: {
+        publisher: "taylor_francis",
+        label: "Taylor & Francis",
+        requiredEnv: ["TANDF_TDM_TOKEN"],
+        optionalEnv: ["TANDF_TDM_ENDPOINT", "TAYLOR_FRANCIS_TDM_TOKEN", "TAYLOR_FRANCIS_TDM_ENDPOINT"],
+        setupHint: "Taylor & Francis TDM often requires an institutional arrangement. Set TANDF_TDM_ENDPOINT and TANDF_TDM_TOKEN when your institution provides them."
+    }
+};
+function now() {
+    return new Date().toISOString();
+}
+function defaultFetch() {
+    if (typeof fetch !== "function") {
+        throw new Error("LongTable publisher access probing requires a fetch-capable Node runtime.");
+    }
+    return fetch;
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function asString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function firstString(value) {
+    return asString(asArray(value)[0]);
+}
+export function normalizeDoi(value) {
+    return value
+        .replace(/^https?:\/\/(dx\.)?doi\.org\//i, "")
+        .replace(/^doi:\s*/i, "")
+        .trim()
+        .toLowerCase();
+}
+function endpoint(url, params) {
+    const parsed = new URL(url);
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== "") {
+            parsed.searchParams.set(key, String(value));
+        }
+    }
+    return parsed.toString();
+}
+function envValue(env, keys) {
+    for (const key of keys) {
+        const value = env[key];
+        if (value && value.trim()) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+function presentEnv(config, env) {
+    return [...config.requiredEnv, ...config.optionalEnv].filter((key) => Boolean(env[key]?.trim()));
+}
+function missingRequiredEnv(config, env) {
+    return config.requiredEnv.filter((key) => !envValue(env, key === "WILEY_TDM_TOKEN"
+        ? ["WILEY_TDM_TOKEN", "WILEY_TDM_CLIENT_TOKEN"]
+        : key === "TANDF_TDM_TOKEN"
+            ? ["TANDF_TDM_TOKEN", "TAYLOR_FRANCIS_TDM_TOKEN"]
+            : [key]));
+}
+function inferPublisherFromText(value) {
+    const normalized = value?.toLowerCase() ?? "";
+    if (!normalized)
+        return undefined;
+    if (/elsevier|sciencedirect/.test(normalized))
+        return "elsevier";
+    if (/springer|nature\.com|springernature/.test(normalized))
+        return "springer_nature";
+    if (/wiley|onlinelibrary/.test(normalized))
+        return "wiley";
+    if (/taylor\s*&?\s*francis|tandfonline|routledge/.test(normalized))
+        return "taylor_francis";
+    return undefined;
+}
+function inferPublisherFromDoi(doi) {
+    if (doi.startsWith("10.1016/"))
+        return "elsevier";
+    if (doi.startsWith("10.1007/") || doi.startsWith("10.1038/"))
+        return "springer_nature";
+    if (doi.startsWith("10.1002/") || doi.startsWith("10.1111/"))
+        return "wiley";
+    if (doi.startsWith("10.1080/") || doi.startsWith("10.1207/"))
+        return "taylor_francis";
+    return undefined;
+}
+export function parsePublisherTarget(value) {
+    if (typeof value !== "string" || value.trim() === "" || value === "auto") {
+        return "auto";
+    }
+    if (PUBLISHERS.includes(value)) {
+        return value;
+    }
+    throw new Error(`Unknown publisher: ${value}`);
+}
+function tdmLinksFromCrossref(rawLinks) {
+    const links = [];
+    for (const entry of asArray(rawLinks)) {
+        const record = asRecord(entry);
+        const url = asString(record.URL) ?? asString(record.url);
+        if (!url) {
+            continue;
+        }
+        links.push({
+            url,
+            contentType: asString(record["content-type"]),
+            contentVersion: asString(record["content-version"]),
+            intendedApplication: asString(record["intended-application"])
+        });
+    }
+    return links;
+}
+function licenseUrlsFromCrossref(rawLicenses) {
+    return asArray(rawLicenses)
+        .map((entry) => asString(asRecord(entry).URL) ?? asString(asRecord(entry).url))
+        .filter((entry) => Boolean(entry));
+}
+export async function discoverCrossrefTdm(doi, env = process.env, httpFetch = defaultFetch()) {
+    const normalizedDoi = normalizeDoi(doi);
+    const url = endpoint(`https://api.crossref.org/works/${encodeURIComponent(normalizedDoi)}`, {
+        mailto: env.LONGTABLE_CONTACT_EMAIL
+    });
+    const response = await httpFetch(url, {
+        headers: {
+            accept: "application/json",
+            "user-agent": "LongTable/0.1.30 (https://github.com/HosungYou/LongTable)"
+        }
+    });
+    if (!response.ok) {
+        throw new Error(`Crossref DOI discovery failed: HTTP ${response.status} ${response.statusText}`);
+    }
+    const payload = asRecord(await response.json());
+    const message = asRecord(payload.message);
+    const publisher = asString(message.publisher);
+    const links = tdmLinksFromCrossref(message.link);
+    const title = firstString(message.title);
+    const sourceUrl = asString(message.URL);
+    const inferredPublisher = inferPublisherFromText(publisher) ??
+        inferPublisherFromText(sourceUrl) ??
+        links.map((link) => inferPublisherFromText(link.url)).find(Boolean) ??
+        inferPublisherFromDoi(normalizedDoi) ??
+        "other";
+    return {
+        doi: normalizedDoi,
+        publisher,
+        inferredPublisher,
+        title,
+        sourceUrl,
+        licenseUrls: licenseUrlsFromCrossref(message.license),
+        links
+    };
+}
+function buildMissingCredentialRecord(publisher, doi, crossref) {
+    const config = PUBLISHER_CONFIGS[publisher];
+    return {
+        publisher,
+        checkedAt: now(),
+        credentialStatus: "missing",
+        entitlementStatus: "unknown",
+        tdmStatus: "not_configured",
+        collectionDepth: "metadata",
+        requiredEnv: config.requiredEnv,
+        presentEnv: [],
+        missingEnv: config.requiredEnv,
+        testedDoi: doi,
+        setupHint: config.setupHint,
+        verificationNote: "Publisher credential is not configured; LongTable can only use metadata or abstract routes.",
+        crossref
+    };
+}
+function baseRecord(input) {
+    const requiredEnv = input.config?.requiredEnv ?? [];
+    const present = input.config && input.env ? presentEnv(input.config, input.env) : [];
+    const missing = input.config && input.env ? missingRequiredEnv(input.config, input.env) : requiredEnv;
+    return {
+        publisher: input.publisher,
+        checkedAt: now(),
+        credentialStatus: input.credentialStatus,
+        entitlementStatus: input.entitlementStatus,
+        tdmStatus: input.tdmStatus,
+        collectionDepth: input.collectionDepth,
+        requiredEnv,
+        presentEnv: present,
+        missingEnv: missing,
+        testedDoi: input.doi,
+        endpoint: input.endpoint,
+        setupHint: input.setupHint,
+        verificationNote: input.verificationNote,
+        licenseNote: input.licenseNote,
+        evidenceSnippet: input.evidenceSnippet,
+        crossref: input.crossref
+    };
+}
+function chooseTextLink(discovery, publisher) {
+    return discovery?.links.find((link) => {
+        const application = link.intendedApplication?.toLowerCase() ?? "";
+        const contentType = link.contentType?.toLowerCase() ?? "";
+        const publisherMatches = publisher ? inferPublisherFromText(link.url) === publisher : true;
+        return publisherMatches &&
+            (application === "" || application.includes("text-mining")) &&
+            !contentType.includes("pdf");
+    });
+}
+async function fetchTextProbe(httpFetch, url, headers) {
+    const response = await httpFetch(url, { headers });
+    const contentType = Object.entries(headers).find(([key]) => key.toLowerCase() === "accept")?.[1] ?? "";
+    let text;
+    if (response.ok && !contentType.includes("application/pdf")) {
+        text = await response.text();
+    }
+    return {
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        text,
+        endpoint: url
+    };
+}
+function snippetFromText(value) {
+    const cleaned = value
+        ?.replace(/<[^>]+>/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!cleaned) {
+        return undefined;
+    }
+    return cleaned.slice(0, 500);
+}
+function recordFromProbeResult(publisher, doi, env, result, crossref, fallbackHint) {
+    const config = PUBLISHER_CONFIGS[publisher];
+    const snippet = snippetFromText(result.text);
+    if (result.ok) {
+        return baseRecord({
+            publisher,
+            doi,
+            config,
+            env,
+            crossref,
+            endpoint: result.endpoint,
+            credentialStatus: "valid",
+            entitlementStatus: "licensed_full_text_available",
+            tdmStatus: "permitted",
+            collectionDepth: snippet ? "licensed_snippet" : "licensed_full_text_local_only",
+            setupHint: config.setupHint,
+            licenseNote: "Publisher endpoint returned content for this DOI. Follow the applicable publisher and institutional TDM terms.",
+            verificationNote: snippet
+                ? "Licensed publisher content was reachable and a short local snippet was extracted."
+                : "Licensed publisher content was reachable, but LongTable did not extract text from the returned format.",
+            evidenceSnippet: snippet
+        });
+    }
+    if (result.status === 401) {
+        return baseRecord({
+            publisher,
+            doi,
+            config,
+            env,
+            crossref,
+            endpoint: result.endpoint,
+            credentialStatus: "invalid",
+            entitlementStatus: "no_access",
+            tdmStatus: "denied",
+            collectionDepth: "metadata",
+            setupHint: config.setupHint,
+            verificationNote: `Publisher rejected the credential for this DOI: HTTP ${result.status} ${result.statusText}.`
+        });
+    }
+    if (result.status === 403) {
+        return baseRecord({
+            publisher,
+            doi,
+            config,
+            env,
+            crossref,
+            endpoint: result.endpoint,
+            credentialStatus: "valid",
+            entitlementStatus: "no_access",
+            tdmStatus: "denied",
+            collectionDepth: "metadata",
+            setupHint: config.setupHint,
+            verificationNote: `Credential was present, but the publisher denied entitlement for this DOI: HTTP ${result.status} ${result.statusText}.`
+        });
+    }
+    return baseRecord({
+        publisher,
+        doi,
+        config,
+        env,
+        crossref,
+        endpoint: result.endpoint,
+        credentialStatus: "present",
+        entitlementStatus: "unknown",
+        tdmStatus: "unknown",
+        collectionDepth: "metadata",
+        setupHint: fallbackHint,
+        verificationNote: `Publisher probe could not confirm access: HTTP ${result.status} ${result.statusText}.`
+    });
+}
+async function probeElsevier(doi, env, httpFetch, crossref) {
+    const config = PUBLISHER_CONFIGS.elsevier;
+    const apiKey = env.ELSEVIER_API_KEY?.trim();
+    if (!apiKey) {
+        return buildMissingCredentialRecord("elsevier", doi, crossref);
+    }
+    const link = chooseTextLink(crossref, "elsevier");
+    const url = link?.url ?? endpoint(`https://api.elsevier.com/content/article/doi/${encodeURIComponent(doi)}`, {
+        httpAccept: "text/plain"
+    });
+    const headers = {
+        accept: "text/plain, application/xml, application/json",
+        "X-ELS-APIKey": apiKey
+    };
+    if (env.ELSEVIER_INST_TOKEN?.trim()) {
+        headers["X-ELS-Insttoken"] = env.ELSEVIER_INST_TOKEN.trim();
+    }
+    if (env.ELSEVIER_AUTHTOKEN?.trim()) {
+        headers["X-ELS-Authtoken"] = env.ELSEVIER_AUTHTOKEN.trim();
+    }
+    const result = await fetchTextProbe(httpFetch, url, headers);
+    return recordFromProbeResult("elsevier", doi, env, result, crossref, config.setupHint);
+}
+async function probeSpringerNature(doi, env, httpFetch, crossref) {
+    const config = PUBLISHER_CONFIGS.springer_nature;
+    const apiKey = env.SPRINGER_NATURE_API_KEY?.trim();
+    if (!apiKey) {
+        return buildMissingCredentialRecord("springer_nature", doi, crossref);
+    }
+    const configuredEndpoint = env.SPRINGER_NATURE_TDM_ENDPOINT?.trim();
+    if (configuredEndpoint) {
+        const url = configuredEndpoint.replace("{doi}", encodeURIComponent(doi));
+        const result = await fetchTextProbe(httpFetch, url, {
+            accept: "text/plain, application/xml, application/json",
+            "X-Api-Key": env.SPRINGER_NATURE_TDM_API_KEY?.trim() ?? apiKey
+        });
+        return recordFromProbeResult("springer_nature", doi, env, result, crossref, config.setupHint);
+    }
+    const url = endpoint("https://api.springernature.com/meta/v2/json", {
+        q: `doi:${doi}`,
+        api_key: apiKey,
+        p: 1
+    });
+    const response = await httpFetch(url, {
+        headers: {
+            accept: "application/json"
+        }
+    });
+    if (!response.ok) {
+        return recordFromProbeResult("springer_nature", doi, env, {
+            ok: response.ok,
+            status: response.status,
+            statusText: response.statusText,
+            endpoint: url
+        }, crossref, config.setupHint);
+    }
+    const payload = asRecord(await response.json());
+    const records = asArray(payload.records);
+    const hasRecord = records.length > 0;
+    return baseRecord({
+        publisher: "springer_nature",
+        doi,
+        config,
+        env,
+        crossref,
+        endpoint: url,
+        credentialStatus: "valid",
+        entitlementStatus: hasRecord ? "abstract_available" : "metadata_only",
+        tdmStatus: "requires_license_review",
+        collectionDepth: hasRecord ? "abstract" : "metadata",
+        setupHint: config.setupHint,
+        licenseNote: "Springer Nature metadata access was verified. Licensed full-text TDM requires a configured TDM endpoint or subscription arrangement.",
+        verificationNote: hasRecord
+            ? "Springer Nature metadata API responded for this DOI; licensed full-text access was not confirmed."
+            : "Springer Nature credential worked, but no metadata record was returned for this DOI."
+    });
+}
+async function probeWiley(doi, env, httpFetch, crossref) {
+    const config = PUBLISHER_CONFIGS.wiley;
+    const token = envValue(env, ["WILEY_TDM_TOKEN", "WILEY_TDM_CLIENT_TOKEN"]);
+    if (!token) {
+        return buildMissingCredentialRecord("wiley", doi, crossref);
+    }
+    const url = `https://api.wiley.com/onlinelibrary/tdm/v1/articles/${encodeURIComponent(doi)}`;
+    const result = await fetchTextProbe(httpFetch, url, {
+        accept: "text/plain, application/xml, application/pdf",
+        "Wiley-TDM-Client-Token": token
+    });
+    return recordFromProbeResult("wiley", doi, env, result, crossref, config.setupHint);
+}
+async function probeTaylorFrancis(doi, env, httpFetch, crossref) {
+    const config = PUBLISHER_CONFIGS.taylor_francis;
+    const token = envValue(env, ["TANDF_TDM_TOKEN", "TAYLOR_FRANCIS_TDM_TOKEN"]);
+    const configuredEndpoint = envValue(env, ["TANDF_TDM_ENDPOINT", "TAYLOR_FRANCIS_TDM_ENDPOINT"]);
+    if (!token || !configuredEndpoint) {
+        return baseRecord({
+            publisher: "taylor_francis",
+            doi,
+            config,
+            env,
+            crossref,
+            credentialStatus: token ? "present" : "missing",
+            entitlementStatus: "unknown",
+            tdmStatus: "requires_license_review",
+            collectionDepth: "metadata",
+            setupHint: config.setupHint,
+            licenseNote: "Taylor & Francis indicates TDM access may require institutional support or a license supplement.",
+            verificationNote: "No Taylor & Francis licensed TDM endpoint was configured, so LongTable did not attempt full-text access."
+        });
+    }
+    const url = configuredEndpoint.replace("{doi}", encodeURIComponent(doi));
+    const result = await fetchTextProbe(httpFetch, url, {
+        accept: "text/plain, application/xml, application/json",
+        authorization: `Bearer ${token}`
+    });
+    return recordFromProbeResult("taylor_francis", doi, env, result, crossref, config.setupHint);
+}
+async function probeKnownPublisher(publisher, doi, env, httpFetch, crossref) {
+    switch (publisher) {
+        case "elsevier":
+            return probeElsevier(doi, env, httpFetch, crossref);
+        case "springer_nature":
+            return probeSpringerNature(doi, env, httpFetch, crossref);
+        case "wiley":
+            return probeWiley(doi, env, httpFetch, crossref);
+        case "taylor_francis":
+            return probeTaylorFrancis(doi, env, httpFetch, crossref);
+    }
+}
+export function publisherConfigs() {
+    return PUBLISHERS.map((publisher) => PUBLISHER_CONFIGS[publisher]);
+}
+export async function probePublisherAccess(input) {
+    const doi = normalizeDoi(input.doi);
+    const env = input.env ?? process.env;
+    const httpFetch = input.fetch ?? defaultFetch();
+    let crossref;
+    try {
+        crossref = await discoverCrossrefTdm(doi, env, httpFetch);
+    }
+    catch {
+        crossref = undefined;
+    }
+    const target = input.publisher ?? "auto";
+    const publisher = target === "auto"
+        ? crossref?.inferredPublisher ?? inferPublisherFromDoi(doi) ?? "other"
+        : target;
+    if (publisher === "other") {
+        return baseRecord({
+            publisher: "other",
+            doi,
+            crossref,
+            credentialStatus: "present",
+            entitlementStatus: crossref?.links.length ? "unknown" : "metadata_only",
+            tdmStatus: crossref?.links.length ? "requires_license_review" : "unknown",
+            collectionDepth: "metadata",
+            setupHint: "No first-party publisher adapter matched this DOI. Use Crossref metadata and the publisher landing page.",
+            verificationNote: "LongTable could not map this DOI to Elsevier, Springer Nature, Wiley, or Taylor & Francis."
+        });
+    }
+    return probeKnownPublisher(publisher, doi, env, httpFetch, crossref);
+}
+export function summarizeConfiguredPublisherAccess(env = process.env) {
+    return PUBLISHERS.map((publisher) => {
+        const config = PUBLISHER_CONFIGS[publisher];
+        const missing = missingRequiredEnv(config, env);
+        return baseRecord({
+            publisher,
+            config,
+            env,
+            credentialStatus: missing.length === 0 ? "present" : "missing",
+            entitlementStatus: "unknown",
+            tdmStatus: missing.length === 0 ? "unknown" : "not_configured",
+            collectionDepth: "metadata",
+            setupHint: config.setupHint,
+            verificationNote: missing.length === 0
+                ? "Credential-like environment variables are present; run a DOI probe to confirm entitlement."
+                : "Required publisher credential environment variables are missing."
+        });
+    });
+}
+export function buildSearchCapabilitySnapshot(records, env = process.env) {
+    return {
+        version: 1,
+        updatedAt: now(),
+        contactEmailPresent: Boolean(env.LONGTABLE_CONTACT_EMAIL?.trim()),
+        records
+    };
+}
+export function searchCapabilitySnapshotPath(home = homedir()) {
+    return join(home, ".longtable", "search-capabilities.json");
+}
+function bestAccessStatus(record) {
+    if (record.entitlementStatus === "licensed_full_text_available" && record.collectionDepth === "licensed_snippet") {
+        return "licensed_full_text_checked";
+    }
+    if (record.entitlementStatus === "licensed_full_text_available") {
+        return "licensed_full_text_available";
+    }
+    if (record.entitlementStatus === "no_access") {
+        return "access_denied";
+    }
+    if (record.entitlementStatus === "abstract_available") {
+        return "abstract_available";
+    }
+    if (record.entitlementStatus === "metadata_only") {
+        return "metadata_only";
+    }
+    return "license_unknown";
+}
+export async function enrichCardsWithPublisherAccess(input) {
+    const env = input.env ?? process.env;
+    const httpFetch = input.fetch ?? defaultFetch();
+    const limit = input.limit ?? 3;
+    const enriched = [];
+    let probes = 0;
+    for (const card of input.cards) {
+        if (!card.doi || probes >= limit) {
+            enriched.push(card);
+            continue;
+        }
+        probes += 1;
+        try {
+            const access = await probePublisherAccess({
+                doi: card.doi,
+                publisher: "auto",
+                env,
+                fetch: httpFetch
+            });
+            enriched.push({
+                ...card,
+                publisher: access.publisher,
+                publisherAccess: access,
+                accessStatus: bestAccessStatus(access),
+                verificationDepth: access.collectionDepth === "licensed_snippet" ? "licensed_snippet" : card.verificationDepth,
+                entitlementSource: access.publisher === "other" ? "crossref_tdm" : "publisher_api",
+                collectionDepth: access.collectionDepth,
+                licenseNote: access.licenseNote,
+                verificationNote: access.verificationNote
+            });
+        }
+        catch (error) {
+            enriched.push({
+                ...card,
+                accessStatus: "license_unknown",
+                verificationNote: `Publisher access probe failed: ${error instanceof Error ? error.message : String(error)}`
+            });
+        }
+    }
+    return enriched;
+}

package/dist/search/rank.js

@@ -41,11 +41,12 @@ function sourceBoost(card) {
     return 1;
 }
 function supportStatus(card, matches, keywords) {
-    if (!card.abstractAvailable) {
+    if (card.verificationDepth === "metadata" || !card.abstractAvailable) {
         return "not_verified";
     }
     const ratio = keywords.length === 0 ? 0 : matches.length / keywords.length;
-    if (ratio >= 0.65)
+    const fullTextChecked = card.verificationDepth === "licensed_snippet" || card.verificationDepth === "legal_full_text";
+    if (fullTextChecked && ratio >= 0.65)
         return "direct_support";
     if (ratio >= 0.35)
         return "indirect_support";
@@ -92,8 +93,27 @@ function scoreCard(card, intent, matches) {
     score += matches.length * 2;
     return Math.max(0, Math.round(score * 10) / 10);
 }
+function accessStrength(card) {
+    if (card.accessStatus === "licensed_full_text_checked")
+        return 6;
+    if (card.accessStatus === "licensed_full_text_available")
+        return 5;
+    if (card.accessStatus === "legal_full_text_available")
+        return 4;
+    if (card.accessStatus === "abstract_available")
+        return 3;
+    if (card.accessStatus === "metadata_only")
+        return 2;
+    if (card.accessStatus === "license_unknown")
+        return 1;
+    return 0;
+}
+function strongerAccess(existing, incoming) {
+    return accessStrength(incoming) > accessStrength(existing) ? incoming : existing;
+}
 function mergeCards(existing, incoming) {
     const sourceRoutes = [...new Set([...existing.sourceRoutes, ...incoming.sourceRoutes])];
+    const stronger = strongerAccess(existing, incoming);
     return {
         ...existing,
         authors: existing.authors.length > 0 ? existing.authors : incoming.authors,
@@ -110,6 +130,14 @@ function mergeCards(existing, incoming) {
         abstractAvailable: existing.abstractAvailable || incoming.abstractAvailable,
         legalFullTextAvailable: existing.legalFullTextAvailable || incoming.legalFullTextAvailable,
         fullTextUrl: existing.fullTextUrl ?? incoming.fullTextUrl,
+        publisher: existing.publisher ?? incoming.publisher,
+        entitlementSource: stronger.entitlementSource ?? existing.entitlementSource ?? incoming.entitlementSource,
+        collectionDepth: stronger.collectionDepth ?? existing.collectionDepth ?? incoming.collectionDepth,
+        licenseNote: stronger.licenseNote ?? existing.licenseNote ?? incoming.licenseNote,
+        publisherAccess: stronger.publisherAccess ?? existing.publisherAccess ?? incoming.publisherAccess,
+        accessStatus: stronger.accessStatus,
+        verificationDepth: stronger.verificationDepth,
+        verificationNote: stronger.verificationNote,
         citationCount: Math.max(existing.citationCount ?? 0, incoming.citationCount ?? 0) || undefined,
         researchDesign: existing.researchDesign ?? incoming.researchDesign,
         constructsOrMeasures: [...new Set([...(existing.constructsOrMeasures ?? []), ...(incoming.constructsOrMeasures ?? [])])],

package/dist/search/run.js

@@ -1,5 +1,6 @@
 import { buildResearchSearchIntent } from "./query.js";
 import { dedupeAndRankCards } from "./rank.js";
+import { enrichCardsWithPublisherAccess } from "./publisher-access.js";
 import { assessSearchSourceCapabilities, runSourceSearch } from "./sources.js";
 function runId() {
     return `evidence_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
@@ -85,6 +86,13 @@ export async function runResearchSearch(input) {
         }
     }
     const rankedCards = dedupeAndRankCards(cards, intent);
+    const finalCards = input.publisherAccess === true
+        ? await enrichCardsWithPublisherAccess({
+            cards: rankedCards,
+            env,
+            fetch: httpFetch
+        })
+        : rankedCards;
     const hasFailure = sourceReports.some((report) => report.status === "failed" || report.status === "skipped");
     const status = hasFailure ? "partial" : "completed";
     return {
@@ -94,7 +102,7 @@ export async function runResearchSearch(input) {
         status,
         intent,
         sourceReports,
-        cards: rankedCards,
+        cards: finalCards,
         skippedSources,
         warnings: [
             ...skippedSources.map((capability) => capability.reason ?? `${capability.source} unavailable.`),

package/dist/search/sources.js

@@ -62,6 +62,30 @@ function inferEvidenceDepth(abstract, legalFullTextAvailable = false) {
         return "abstract_only";
     return "metadata_only";
 }
+function inferAccessStatus(abstract, legalFullTextAvailable = false) {
+    if (legalFullTextAvailable)
+        return "legal_full_text_available";
+    if (abstract)
+        return "abstract_available";
+    return "metadata_only";
+}
+function inferVerificationDepth(abstract) {
+    if (abstract)
+        return "abstract";
+    return "metadata";
+}
+function verificationNote(abstract, legalFullTextAvailable = false) {
+    if (legalFullTextAvailable && abstract) {
+        return "Legal full text URL was found, but this card is abstract-based and not full-paper verified.";
+    }
+    if (legalFullTextAvailable) {
+        return "Legal full text URL was found, but LongTable did not retrieve or verify the full text.";
+    }
+    if (abstract) {
+        return "Abstract is available; citation support is abstract-based, not full-paper verified.";
+    }
+    return "Metadata exists; citation support has not been verified against abstract or full text.";
+}
 function inferResearchDesign(abstract) {
     const normalized = abstract?.toLowerCase() ?? "";
     if (!normalized)
@@ -111,6 +135,9 @@ function baseCard(input) {
         abstract,
         abstractAvailable: Boolean(abstract),
         evidenceDepth: inferEvidenceDepth(abstract, legalFullTextAvailable),
+        accessStatus: inferAccessStatus(abstract, legalFullTextAvailable),
+        verificationDepth: inferVerificationDepth(abstract),
+        verificationNote: verificationNote(abstract, legalFullTextAvailable),
         legalFullTextAvailable,
         fullTextUrl: input.fullTextUrl,
         citationCount: input.citationCount,
@@ -128,7 +155,7 @@ async function fetchJson(context, url) {
     const response = await context.fetch(url, {
         headers: {
             "accept": "application/json",
-            "user-agent": "LongTable/0.1.29 (https://github.com/HosungYou/LongTable)"
+            "user-agent": "LongTable/0.1.30 (https://github.com/HosungYou/LongTable)"
         }
     });
     if (!response.ok) {
@@ -140,7 +167,7 @@ async function fetchText(context, url) {
     const response = await context.fetch(url, {
         headers: {
             "accept": "application/xml, text/xml, application/atom+xml, text/plain",
-            "user-agent": "LongTable/0.1.29 (https://github.com/HosungYou/LongTable)"
+            "user-agent": "LongTable/0.1.30 (https://github.com/HosungYou/LongTable)"
         }
     });
     if (!response.ok) {

package/dist/search/types.d.ts

@@ -1,7 +1,17 @@
 export declare const SEARCH_SOURCES: readonly ["crossref", "arxiv", "openalex", "semantic_scholar", "pubmed", "eric", "doaj", "unpaywall"];
 export type SearchSource = typeof SEARCH_SOURCES[number];
+export declare const PUBLISHERS: readonly ["elsevier", "springer_nature", "wiley", "taylor_francis"];
+export type Publisher = typeof PUBLISHERS[number];
+export type PublisherProbeTarget = Publisher | "auto";
 export type ResearchSearchIntentKind = "literature" | "theory" | "measurement" | "citation" | "metadata" | "venue";
 export type EvidenceDepth = "metadata_only" | "abstract_only" | "legal_full_text_available" | "legal_full_text_unavailable" | "secondary_summary_only";
+export type AccessStatus = "metadata_only" | "abstract_available" | "legal_full_text_available" | "licensed_full_text_available" | "licensed_full_text_checked" | "access_denied" | "license_unknown";
+export type VerificationDepth = "metadata" | "abstract" | "legal_full_text" | "licensed_snippet" | "secondary";
+export type EntitlementSource = "crossref_tdm" | "publisher_api" | "institutional_token" | "user_api_key" | "none";
+export type CollectionDepth = "metadata" | "abstract" | "licensed_snippet" | "licensed_full_text_local_only";
+export type CredentialStatus = "missing" | "present" | "valid" | "invalid";
+export type EntitlementStatus = "unknown" | "no_access" | "metadata_only" | "abstract_available" | "licensed_full_text_available";
+export type TdmStatus = "unknown" | "not_configured" | "permitted" | "denied" | "requires_license_review";
 export type CitationSupportStatus = "direct_support" | "indirect_support" | "background" | "questionable_fit" | "not_verified";
 export type SourceRunStatus = "completed" | "skipped" | "failed";
 export type EvidenceRunStatus = "completed" | "partial" | "blocked";
@@ -39,8 +49,16 @@ export interface EvidenceCard {
     abstract?: string;
     abstractAvailable: boolean;
     evidenceDepth: EvidenceDepth;
+    accessStatus: AccessStatus;
+    verificationDepth: VerificationDepth;
+    verificationNote: string;
     legalFullTextAvailable: boolean;
     fullTextUrl?: string;
+    publisher?: Publisher | "other";
+    entitlementSource?: EntitlementSource;
+    collectionDepth?: CollectionDepth;
+    licenseNote?: string;
+    publisherAccess?: PublisherAccessRecord;
     citationCount?: number;
     researchDesign?: string;
     constructsOrMeasures?: string[];
@@ -120,4 +138,50 @@ export interface RunResearchSearchInput extends BuildSearchIntentInput {
     env?: Record<string, string | undefined>;
     fetch?: SearchFetch;
     allowPartial?: boolean;
+    publisherAccess?: boolean;
+}
+export interface CrossrefTdmLink {
+    url: string;
+    contentType?: string;
+    contentVersion?: string;
+    intendedApplication?: string;
+}
+export interface CrossrefTdmDiscovery {
+    doi: string;
+    publisher?: string;
+    inferredPublisher?: Publisher | "other";
+    title?: string;
+    sourceUrl?: string;
+    licenseUrls: string[];
+    links: CrossrefTdmLink[];
+}
+export interface PublisherAccessRecord {
+    publisher: Publisher | "other";
+    checkedAt: string;
+    credentialStatus: CredentialStatus;
+    entitlementStatus: EntitlementStatus;
+    tdmStatus: TdmStatus;
+    collectionDepth: CollectionDepth;
+    requiredEnv: string[];
+    presentEnv: string[];
+    missingEnv: string[];
+    testedDoi?: string;
+    endpoint?: string;
+    setupHint: string;
+    licenseNote?: string;
+    verificationNote: string;
+    evidenceSnippet?: string;
+    crossref?: CrossrefTdmDiscovery;
+}
+export interface SearchCapabilitySnapshot {
+    version: 1;
+    updatedAt: string;
+    contactEmailPresent: boolean;
+    records: PublisherAccessRecord[];
+}
+export interface PublisherProbeInput {
+    doi: string;
+    publisher?: PublisherProbeTarget;
+    env?: Record<string, string | undefined>;
+    fetch?: SearchFetch;
 }

package/dist/search/types.js

@@ -8,3 +8,9 @@ export const SEARCH_SOURCES = [
     "doaj",
     "unpaywall"
 ];
+export const PUBLISHERS = [
+    "elsevier",
+    "springer_nature",
+    "wiley",
+    "taylor_francis"
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@longtable/cli",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "private": false,
   "description": "Researcher-facing LongTable CLI",
   "type": "module",
@@ -28,12 +28,12 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@longtable/checkpoints": "0.1.29",
-    "@longtable/core": "0.1.29",
-    "@longtable/memory": "0.1.29",
-    "@longtable/provider-claude": "0.1.29",
-    "@longtable/provider-codex": "0.1.29",
-    "@longtable/setup": "0.1.29"
+    "@longtable/checkpoints": "0.1.30",
+    "@longtable/core": "0.1.30",
+    "@longtable/memory": "0.1.30",
+    "@longtable/provider-claude": "0.1.30",
+    "@longtable/provider-codex": "0.1.30",
+    "@longtable/setup": "0.1.30"
   },
   "devDependencies": {
     "@types/node": "^22.10.1",