@longtable/cli 0.1.43 → 0.1.45

package/README.md

@@ -86,9 +86,18 @@ summary without starting a provider session.
 - `CURRENT.md`: human-facing current view regenerated from state
 - `.longtable/project.json`: stable project identity
 - `.longtable/current-session.json`: current session cursor
-- `.longtable/state.json`: layered memory state
+- `.longtable/state.json`: layered memory state, including First Research
+  Shape and Research Specification when the interview has produced them
 - `.longtable/sessions/`: historical snapshots
 
+`$longtable-interview` first stabilizes a short First Research Shape. When the
+conversation is substantive enough, it should also preserve a Research
+Specification covering scope, construct ontology, theory framing,
+measurement/coding, method options, evidence/access requirements, epistemic
+alignment, protected decisions, open questions, and next actions. `CURRENT.md`
+renders that specification so later agents do not need to reconstruct the full
+interview from memory.
+
 ## Why This Shape
 
 The CLI tries to keep the root simple for novice researchers while preserving enough structure for power users and downstream tooling.
@@ -140,6 +149,25 @@ That setup writes the MCP configuration and Codex elicitation approval needed
 for form-style checkpoint prompts. Without it, LongTable keeps the same
 `QuestionRecord` pending and falls back to numbered text.
 
+## Runtime Boundary
+
+LongTable is not a replacement wrapper for Codex. Markdown docs and generated
+skills are soft policy; hooks, MCP elicitation, CLI gates, and `.longtable/`
+state are the enforcement layers.
+
+LongTable should ask and stop before acting when the next step would change or
+settle one of four high-risk research commitments:
+
+1. Research question or scope
+2. Theory frame or construct map
+3. Measurement, coding, or extraction standard
+4. Method design or analysis strategy
+
+Low-risk reversible work should continue with visible assumptions instead of a
+hook interruption. If human knowledge, AI inference, and durable project state
+conflict, LongTable should prefer the most explicit durable state; if that state
+is not explicit enough, it should ask the researcher for clarity.
+
 Explicit short forms are available when needed:
 
 ```text
@@ -241,16 +269,17 @@ 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.
+Scholarly access is configured separately through `longtable access setup`.
+It records readiness for metadata, OA full text, institutional access,
+publisher API/TDM credentials, and manual PDFs without storing secrets.
+Publisher probes cover Elsevier, Springer Nature, Wiley, and Taylor & Francis.
 
 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 access setup
+longtable access 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

@@ -9,7 +9,7 @@ import { dirname, join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { classifyCheckpointTrigger } from "@longtable/checkpoints";
-import { assessSearchSourceCapabilities, buildResearchSearchIntent, buildSearchCapabilitySnapshot, parsePublisherTarget, probePublisherAccess, publisherConfigs, runResearchSearch, searchCapabilitySnapshotPath, summarizeConfiguredPublisherAccess } from "./search/index.js";
+import { assessSearchSourceCapabilities, buildResearchSearchIntent, parsePublisherTarget, probePublisherAccess, publisherConfigs, runResearchSearch, SEARCH_SOURCES, 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";
@@ -109,10 +109,11 @@ 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 access setup [--doi <doi>] [--json]",
+        "  longtable access status [--json]",
+        "  longtable access doctor [--doi <doi>] [--publisher auto|elsevier|springer_nature|wiley|taylor_francis|all] [--json]",
+        "  longtable access probe --doi <doi> [--publisher auto|elsevier|springer_nature|wiley|taylor_francis] [--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>]",
@@ -154,7 +155,7 @@ function parseArgs(argv) {
     const values = {};
     let subcommand = maybeSubcommand;
     const modeCommand = command && VALID_MODES.has(command);
-    const directCommand = command && ["init", "setup", "start", "resume", "doctor", "status", "audit", "roles", "show", "install", "mcp", "codex", "claude", "ask", "clarify", "question", "clear-question", "prune-questions", "panel", "decide", "sentinel", "team", "search"].includes(command);
+    const directCommand = command && ["init", "setup", "start", "resume", "doctor", "status", "audit", "roles", "show", "install", "mcp", "codex", "claude", "ask", "clarify", "question", "clear-question", "prune-questions", "panel", "decide", "sentinel", "team", "access", "search"].includes(command);
     let startIndex = 1;
     if (modeCommand) {
         subcommand = undefined;
@@ -163,7 +164,7 @@ function parseArgs(argv) {
     else if (command === "codex" || command === "claude" || command === "mcp") {
         startIndex = 2;
     }
-    else if (command === "search" && maybeSubcommand && !maybeSubcommand.startsWith("--")) {
+    else if ((command === "access" || command === "search") && maybeSubcommand && !maybeSubcommand.startsWith("--")) {
         subcommand = maybeSubcommand;
         startIndex = 2;
     }
@@ -1789,6 +1790,11 @@ const QUESTION_AUDIT_FIXTURES = [
         prompt: "Protected decision closure pressure: measurement. User prompt: Implement the plan.",
         expectedKinds: ["research_commitment"]
     },
+    {
+        id: "scholarly_access_policy",
+        prompt: "메타분석 논문들의 PDF와 full text를 수집해서 원문 기반으로 코딩해줘.",
+        expectedKinds: ["evidence_risk"]
+    },
     {
         id: "low_stakes_copyedit",
         prompt: "문장 끝 공백만 정리해줘.",
@@ -2347,6 +2353,86 @@ async function recordEvidenceRun(run, workingDirectory) {
     await syncCurrentWorkspaceView(context);
     return evidencePath;
 }
+function nowIso() {
+    return new Date().toISOString();
+}
+function uniqueAccessRoutes(routes) {
+    return [...new Set(routes)];
+}
+function accessReadinessPath(home = homedir()) {
+    return join(home, ".longtable", "access-readiness.json");
+}
+function readAccessReadinessProfile() {
+    const path = accessReadinessPath();
+    if (!existsSync(path)) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function hasPublisherCredentialSignal(records) {
+    return records.some((record) => record.presentEnv.length > 0 || record.credentialStatus !== "missing");
+}
+function readinessPublisherRecord(record) {
+    const safeRecord = { ...record };
+    delete safeRecord.evidenceSnippet;
+    return safeRecord;
+}
+function inferAccessRoutes(records) {
+    const routes = ["metadata"];
+    if (hasPublisherCredentialSignal(records)) {
+        routes.push("publisher_tdm");
+    }
+    return routes;
+}
+function buildAccessReadinessProfile(options) {
+    const publisherRecords = options.publisherRecords ?? summarizeConfiguredPublisherAccess(env);
+    const routes = uniqueAccessRoutes(options.routes?.length ? options.routes : inferAccessRoutes(publisherRecords));
+    const disabled = options.readiness === "disabled";
+    const institutionalMode = options.institutionalAccessMode;
+    const institutionalAccess = routes.includes("institutional")
+        ? {
+            available: true,
+            mode: institutionalMode ?? "unknown",
+            verified: false,
+            note: "LongTable records institutional access readiness only. The researcher must complete VPN/proxy/library login directly."
+        }
+        : undefined;
+    return {
+        version: 1,
+        updatedAt: nowIso(),
+        readiness: options.readiness,
+        metadataSources: [...SEARCH_SOURCES],
+        routes: disabled ? [] : routes,
+        ...(institutionalAccess ? { institutionalAccess } : {}),
+        publisherTdm: disabled
+            ? "deferred"
+            : routes.includes("publisher_tdm")
+                ? hasPublisherCredentialSignal(publisherRecords) ? "configured" : "unknown"
+                : "not_configured",
+        oaOnly: !disabled && routes.includes("oa_full_text") && !routes.includes("institutional") && !routes.includes("publisher_tdm"),
+        manualPdfAllowed: !disabled && routes.includes("manual_pdf"),
+        storesSecrets: false,
+        requiresCheckpointBeforeSearch: options.readiness === "deferred",
+        requiresCheckpointBeforeFullText: options.readiness !== "disabled",
+        ...(disabled ? {} : {
+            publisherAccess: {
+                contactEmailPresent: Boolean(env.LONGTABLE_CONTACT_EMAIL?.trim()),
+                records: publisherRecords.map(readinessPublisherRecord)
+            }
+        })
+    };
+}
+async function saveAccessReadinessProfile(profile) {
+    const profilePath = accessReadinessPath();
+    await mkdir(dirname(profilePath), { recursive: true });
+    await writeJsonFile(profilePath, profile);
+    return profilePath;
+}
 function renderPublisherAccessRecord(record) {
     const envSummary = record.missingEnv.length > 0
         ? `missing ${record.missingEnv.join(", ")}`
@@ -2381,12 +2467,6 @@ function renderPublisherAccessRecords(title, records, capabilityPath) {
     }
     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()) {
@@ -2398,9 +2478,48 @@ async function probeAllPublishers(doi) {
     }
     return records;
 }
-async function runSearchProbe(args) {
+function renderAccessReadinessProfile(profile, profilePath = accessReadinessPath()) {
+    const lines = [
+        "LongTable Scholarly Access Readiness",
+        `- profile: ${profilePath}`,
+        `- readiness: ${profile.readiness}`,
+        `- routes: ${profile.routes.length > 0 ? profile.routes.join(", ") : "none"}`,
+        `- metadata sources: ${profile.metadataSources.join(", ")}`,
+        `- OA-only: ${profile.oaOnly ? "yes" : "no"}`,
+        `- manual PDF allowed: ${profile.manualPdfAllowed ? "yes" : "no"}`,
+        `- publisher/TDM: ${profile.publisherTdm}`,
+        `- stores secrets: ${profile.storesSecrets ? "yes" : "no"}`,
+        `- checkpoint before search: ${profile.requiresCheckpointBeforeSearch ? "yes" : "no"}`,
+        `- checkpoint before full text: ${profile.requiresCheckpointBeforeFullText ? "yes" : "no"}`
+    ];
+    if (profile.institutionalAccess) {
+        lines.push(`- institutional access: ${profile.institutionalAccess.mode}; verified: no`);
+        lines.push(`  note: ${profile.institutionalAccess.note}`);
+    }
+    if (profile.publisherAccess) {
+        lines.push(`- contact email: ${profile.publisherAccess.contactEmailPresent ? "present" : "missing"}`);
+        lines.push(`- publisher adapters: ${profile.publisherAccess.records.length}`);
+    }
+    return lines.join("\n");
+}
+function renderAccessDoctor(profile, records, profilePath) {
+    const metadataCapabilities = assessSearchSourceCapabilities([...SEARCH_SOURCES], env);
+    const lines = [
+        "LongTable Scholarly Access Doctor",
+        `- readiness profile: ${profile ? "present" : "missing"} (${profilePath})`,
+        `- metadata sources: ${metadataCapabilities.map((capability) => `${capability.source}:${capability.enabled ? "available" : "needs_config"}`).join(", ")}`,
+        "- institutional access: LongTable cannot verify VPN/proxy/SSO until the researcher logs in.",
+        "- secrets: LongTable stores env var names and capability status only, never credential values.",
+        renderPublisherAccessRecords("Publisher API/TDM adapters", records)
+    ];
+    if (!profile) {
+        lines.push("- next: run `longtable access setup` before PDF collection or full-text extraction.");
+    }
+    return lines.join("\n");
+}
+async function runAccessProbe(args) {
     if (typeof args.doi !== "string" || !args.doi.trim()) {
-        throw new Error("`longtable search probe` requires --doi <doi>.");
+        throw new Error("`longtable access probe` requires --doi <doi>.");
     }
     const publisher = parsePublisherTarget(args.publisher);
     const record = await probePublisherAccess({
@@ -2416,7 +2535,7 @@ async function runSearchProbe(args) {
     }
     return [record];
 }
-async function runSearchDoctor(args) {
+async function collectAccessDoctorRecords(args) {
     let records;
     if (typeof args.doi === "string" && args.doi.trim()) {
         if (args.publisher === "all") {
@@ -2434,104 +2553,148 @@ async function runSearchDoctor(args) {
     else {
         records = summarizeConfiguredPublisherAccess(env);
     }
-    const snapshotPath = searchCapabilitySnapshotPath();
-    const snapshotExists = existsSync(snapshotPath);
+    return records;
+}
+async function runAccessDoctor(args) {
+    const records = await collectAccessDoctorRecords(args);
+    const profilePath = accessReadinessPath();
+    const profile = readAccessReadinessProfile();
     if (args.json === true) {
         console.log(JSON.stringify({
-            capabilityFile: snapshotPath,
-            capabilityFileExists: snapshotExists,
+            readinessFile: profilePath,
+            readinessFileExists: Boolean(profile),
+            readiness: profile,
+            metadataSources: assessSearchSourceCapabilities([...SEARCH_SOURCES], env),
             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.");
-        }
+        console.log(renderAccessDoctor(profile, records, profilePath));
     }
     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;
+async function publisherRecordsForAccessSetup(args, routes) {
+    const defaultDoi = typeof args.doi === "string" ? args.doi : undefined;
+    if (!routes.includes("publisher_tdm")) {
+        return summarizeConfiguredPublisherAccess(env);
     }
-    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("");
-        }
+    if (defaultDoi) {
+        return probeAllPublishers(defaultDoi);
     }
-    finally {
-        rl.close();
+    if (input.isTTY && output.isTTY && args.json !== true) {
+        const doi = await promptText("Optional DOI for publisher/TDM probing. Leave blank to record env-var readiness only.", false);
+        return doi
+            ? await probeAllPublishers(doi)
+            : summarizeConfiguredPublisherAccess(env);
     }
-    return records;
+    return summarizeConfiguredPublisherAccess(env);
 }
-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);
+async function runInteractiveAccessSetup(args) {
+    const readiness = await promptChoice("Scholarly Access Readiness\n\nWill this machine/account use scholarly search or full-text access?", [
+        { id: "configured", label: "Configure now", description: "Record access capability without storing secrets." },
+        { id: "deferred", label: "Ask later", description: "Defer setup and require an access checkpoint before search or extraction." },
+        { id: "disabled", label: "Do not use", description: "This project will use metadata/manual notes without scholarly full-text access." }
+    ]);
+    if (readiness !== "configured") {
+        return buildAccessReadinessProfile({ readiness, routes: [] });
+    }
+    const routeSelections = await promptMultiChoice("Select every scholarly access route that is available or intended. Secrets are never stored.", [
+        { id: "metadata", label: "Open metadata", description: "Crossref, OpenAlex, Semantic Scholar, PubMed, ERIC, DOAJ, Unpaywall." },
+        { id: "oa_full_text", label: "OA full text", description: "Use open-access PDF/full-text when legally available." },
+        { id: "institutional", label: "Institutional access", description: "VPN, library proxy, or browser SSO handled by the researcher." },
+        { id: "publisher_tdm", label: "Publisher API/TDM", description: "Use configured publisher API/TDM environment variables." },
+        { id: "manual_pdf", label: "Manual PDFs", description: "Researcher supplies PDFs; LongTable organizes/probes allowed extraction." },
+        { id: "unknown", label: "Unknown", description: "Keep access uncertain and require a checkpoint before full-text work." }
+    ]);
+    const routes = uniqueAccessRoutes(routeSelections.length > 0 ? routeSelections : ["metadata"]);
+    const institutionalAccessMode = routes.includes("institutional")
+        ? await promptChoice("How will institutional access be completed? The researcher handles login/MFA directly.", [
+            { id: "vpn", label: "VPN", description: "Researcher connects through school or institutional VPN." },
+            { id: "library_proxy", label: "Library proxy", description: "Researcher uses proxy links or library resolver." },
+            { id: "browser_sso", label: "Browser SSO", description: "Researcher logs into library/publisher SSO in the browser." },
+            { id: "unknown", label: "Unknown", description: "The route exists but is not yet specified." }
+        ])
+        : undefined;
+    const publisherRecords = await publisherRecordsForAccessSetup(args, routes);
+    return buildAccessReadinessProfile({
+        readiness,
+        routes,
+        institutionalAccessMode,
+        publisherRecords
+    });
+}
+async function runAccessSetup(args) {
+    const records = typeof args.doi === "string" && args.doi.trim()
+        ? await probeAllPublishers(args.doi)
+        : summarizeConfiguredPublisherAccess(env);
+    const profile = input.isTTY && output.isTTY && args.json !== true
+        ? await runInteractiveAccessSetup(args)
+        : buildAccessReadinessProfile({
+            readiness: "configured",
+            routes: inferAccessRoutes(records),
+            publisherRecords: records
+        });
+    const profilePath = await saveAccessReadinessProfile(profile);
     if (args.json === true) {
         console.log(JSON.stringify({
-            capabilityFile: snapshotPath,
-            snapshot: buildSearchCapabilitySnapshot(records, env)
+            readinessFile: profilePath,
+            profile
         }, null, 2));
         return;
     }
-    console.log(renderPublisherAccessRecords("LongTable Search Publisher Access Setup", records, snapshotPath));
+    console.log(renderAccessReadinessProfile(profile, profilePath));
 }
-async function runSearch(subcommand, args) {
-    if (subcommand === "probe") {
-        await runSearchProbe(args);
+async function runAccessStatus(args) {
+    const profilePath = accessReadinessPath();
+    const profile = readAccessReadinessProfile();
+    if (args.json === true) {
+        console.log(JSON.stringify({
+            readinessFile: profilePath,
+            readinessFileExists: Boolean(profile),
+            readiness: profile
+        }, null, 2));
         return;
     }
-    if (subcommand === "doctor" || subcommand === "status") {
-        await runSearchDoctor(args);
+    if (!profile) {
+        console.log([
+            "LongTable Scholarly Access Readiness",
+            `- profile: missing (${profilePath})`,
+            "- next: run `longtable access setup` before PDF collection or full-text extraction."
+        ].join("\n"));
         return;
     }
+    console.log(renderAccessReadinessProfile(profile, profilePath));
+}
+async function runAccess(subcommand, args) {
     if (subcommand === "setup") {
-        await runSearchSetup(args);
+        await runAccessSetup(args);
+        return;
+    }
+    if (subcommand === "status") {
+        await runAccessStatus(args);
+        return;
+    }
+    if (subcommand === "doctor") {
+        await runAccessDoctor(args);
         return;
     }
+    if (subcommand === "probe") {
+        await runAccessProbe(args);
+        return;
+    }
+    if (!subcommand) {
+        await runAccessStatus(args);
+        return;
+    }
+    throw new Error(`Unknown access subcommand: ${subcommand}`);
+}
+function movedSearchAccessCommand(subcommand) {
+    return new Error(`\`longtable search ${subcommand}\` has moved. Use \`longtable access ${subcommand}\`.`);
+}
+async function runSearch(subcommand, args) {
+    if (subcommand === "setup" || subcommand === "doctor" || subcommand === "status" || subcommand === "probe") {
+        throw movedSearchAccessCommand(subcommand);
+    }
     if (subcommand) {
         throw new Error(`Unknown search subcommand: ${subcommand}`);
     }
@@ -3524,6 +3687,10 @@ async function main() {
         await runMcpSubcommand(subcommand, values);
         return;
     }
+    if (command === "access") {
+        await runAccess(subcommand, values);
+        return;
+    }
     if (command === "search") {
         await runSearch(subcommand, values);
         return;

package/dist/longtable-codex-native-hook.js

@@ -131,6 +131,11 @@ function looksLikeResearchCommitmentPrompt(prompt) {
         /\b(change|revise|update|replace|reframe|modify|alter)\b/i.test(prompt) ||
         /바꾸|변경|수정|교체|전환|재설정/.test(prompt));
 }
+function looksLikeAccessSensitiveResearchAction(prompt) {
+    const normalized = prompt.trim();
+    return /\b(pdf|full[- ]?text|tdm|publisher api|institutional access|library login|vpn|proxy|subscription|paper collection|source collection|corpus|download)\b/i.test(normalized)
+        || /PDF|원문|전문|기관\s*구독|기관구독|구독|VPN|프록시|도서관|라이브러리|TDM|논문\s*수집|문헌\s*수집|코퍼스|다운로드/.test(normalized);
+}
 function looksLikeQuestionGenerationPrompt(prompt) {
     return /\b(needed questions?|necessary questions?|question generation|clarifying questions?|ask questions?)\b/i.test(prompt)
         || /필요한\s*질문|질문을\s*(모두|많이|생성)|질문\s*생성|물어봐|질문해/.test(prompt);
@@ -184,11 +189,12 @@ function shouldSurfaceInterviewContext(prompt) {
     return looksLikeExplicitInterviewPrompt(prompt) || looksLikeResearchStateConfirmationPrompt(prompt);
 }
 function shouldCreateRequiredQuestionsForPrompt(prompt) {
-    return !looksLikeLongTableProductOrToolingPrompt(prompt) && looksLikeResearchCommitmentPrompt(prompt);
+    return !looksLikeLongTableProductOrToolingPrompt(prompt) &&
+        (looksLikeResearchCommitmentPrompt(prompt) || looksLikeAccessSensitiveResearchAction(prompt));
 }
 function shouldApplyProtectedDecisionClosure(runtime, prompt) {
     return Boolean(runtime.context.session.protectedDecision) &&
-        shouldCreateRequiredQuestionsForPrompt(prompt) &&
+        looksLikeResearchCommitmentPrompt(prompt) &&
         !looksLikeQuestionGenerationPrompt(prompt) &&
         !looksLikeMultiCommitmentChangePrompt(prompt);
 }

package/dist/project-session.d.ts

@@ -34,6 +34,58 @@ export interface FirstResearchShape {
     sourceHookId?: string;
     confirmedAt?: string;
 }
+export interface ResearchSpecification {
+    title: string;
+    status?: "draft" | "confirmed" | "deferred";
+    createdAt?: string;
+    updatedAt?: string;
+    sourceHookId?: string;
+    researchDirection: {
+        question?: string;
+        purpose: string;
+        scopeBoundary?: string;
+        inclusionCriteria?: string[];
+        exclusionCriteria?: string[];
+    };
+    constructOntology: {
+        coreConstructs: string[];
+        distinctions: string[];
+        termsToAvoidCollapsing?: string[];
+    };
+    theoryAndFraming: {
+        anchors: string[];
+        alternatives?: string[];
+        overreachRisks?: string[];
+    };
+    measurementCoding: {
+        variablesOrConstructs: string[];
+        evidenceTypes: string[];
+        codingRules: string[];
+        openStandards?: string[];
+    };
+    methodAnalysis: {
+        design?: string;
+        analysisOptions: string[];
+        dataSufficiencyCriteria?: string[];
+        unsettledChoices?: string[];
+    };
+    evidenceAccess: {
+        requiredSources?: string[];
+        accessRequirements?: string[];
+        evidenceStandards?: string[];
+    };
+    epistemicAlignment: {
+        researcherKnowledge?: string[];
+        projectStatePriority?: string[];
+        aiInferenceLimits?: string[];
+        conflictResolutionRule?: string;
+    };
+    protectedDecisions: string[];
+    openQuestions: string[];
+    nextActions: string[];
+    confidence: "low" | "medium" | "high";
+    confirmedAt?: string;
+}
 export interface LongTableInterviewTurn {
     id: string;
     index: number;
@@ -59,6 +111,7 @@ export interface LongTableHookRun {
     provider?: ProviderKind;
     turns?: LongTableInterviewTurn[];
     firstResearchShape?: FirstResearchShape;
+    researchSpecification?: ResearchSpecification;
     qualityNotes?: string[];
     rationale?: string[];
     linkedQuestionRecordIds?: string[];
@@ -67,6 +120,7 @@ export interface LongTableHookRun {
 export type LongTableWorkspaceState = ResearchState & {
     hooks?: LongTableHookRun[];
     firstResearchShape?: FirstResearchShape;
+    researchSpecification?: ResearchSpecification;
 };
 export interface LongTableProjectRecord {
     schemaVersion: 1;
@@ -102,6 +156,7 @@ export interface LongTableSessionRecord {
     openQuestions?: string[];
     startInterview?: StartInterviewSession;
     firstResearchShape?: FirstResearchShape;
+    researchSpecification?: ResearchSpecification;
     requestedPerspectives: string[];
     disagreementPreference: ProjectDisagreementPreference;
     activeModes?: string[];
@@ -132,6 +187,11 @@ export interface LongTableWorkspaceInspection {
         currentBlocker?: string;
         requestedPerspectives: string[];
         disagreementPreference: ProjectDisagreementPreference;
+        researchSpecification?: {
+            title: string;
+            status: "draft" | "confirmed" | "deferred";
+            confidence: "low" | "medium" | "high";
+        };
     };
     files?: {
         project: string;
@@ -224,6 +284,16 @@ export declare function summarizeLongTableInterview(options: {
     state: LongTableWorkspaceState;
     session: LongTableSessionRecord;
 }>;
+export declare function summarizeLongTableResearchSpecification(options: {
+    context: LongTableProjectContext;
+    hookId?: string;
+    specification: ResearchSpecification;
+}): Promise<{
+    hook?: LongTableHookRun;
+    specification: ResearchSpecification;
+    state: LongTableWorkspaceState;
+    session: LongTableSessionRecord;
+}>;
 export declare function listBlockingWorkspaceQuestions(context: LongTableProjectContext): Promise<QuestionRecord[]>;
 export declare function listBlockingWorkspaceObligations(context: LongTableProjectContext): Promise<LongTableQuestionObligation[]>;
 export declare function assertWorkspaceNotBlocked(context: LongTableProjectContext): Promise<void>;

package/dist/project-session.js

@@ -94,6 +94,9 @@ function buildNextAction(session) {
         : "Open with your current goal in one sentence, then ask LongTable for the first concrete research move.";
 }
 function buildResumeHint(session) {
+    if (session.researchSpecification) {
+        return `I want to continue from the Research Specification: ${session.researchSpecification.title}.`;
+    }
     if (session.firstResearchShape) {
         return `I want to continue from the First Research Shape: ${session.firstResearchShape.handle}.`;
     }
@@ -106,6 +109,60 @@ function buildResumeHint(session) {
         ? `I want to continue ${session.currentGoal}. The unresolved blocker is ${session.currentBlocker}.`
         : `I want to continue ${session.currentGoal}.`;
 }
+function renderResearchSpecificationSummary(specification, locale) {
+    const korean = locale === "ko";
+    const lines = [
+        "",
+        korean ? "## Research Specification" : "## Research Specification",
+        `- ${korean ? "제목" : "Title"}: ${specification.title}`,
+        `- ${korean ? "상태" : "Status"}: ${specification.confirmedAt ? "confirmed" : specification.status ?? "draft"}`,
+        `- ${korean ? "신뢰도" : "Confidence"}: ${specification.confidence}`
+    ];
+    if (specification.researchDirection.question) {
+        lines.push(`- ${korean ? "연구 질문" : "Question"}: ${specification.researchDirection.question}`);
+    }
+    lines.push(`- ${korean ? "목적" : "Purpose"}: ${specification.researchDirection.purpose}`);
+    if (specification.researchDirection.scopeBoundary) {
+        lines.push(`- ${korean ? "범위 경계" : "Scope boundary"}: ${specification.researchDirection.scopeBoundary}`);
+    }
+    if (specification.constructOntology.coreConstructs.length > 0) {
+        lines.push(`- ${korean ? "핵심 construct" : "Core constructs"}: ${specification.constructOntology.coreConstructs.join("; ")}`);
+    }
+    if (specification.constructOntology.distinctions.length > 0) {
+        lines.push(`- ${korean ? "구분해야 할 차이" : "Key distinctions"}: ${specification.constructOntology.distinctions.join("; ")}`);
+    }
+    if (specification.theoryAndFraming.anchors.length > 0) {
+        lines.push(`- ${korean ? "이론 앵커" : "Theory anchors"}: ${specification.theoryAndFraming.anchors.join("; ")}`);
+    }
+    if (specification.measurementCoding.codingRules.length > 0) {
+        lines.push(`- ${korean ? "코딩 규칙" : "Coding rules"}: ${specification.measurementCoding.codingRules.join("; ")}`);
+    }
+    if (specification.methodAnalysis.analysisOptions.length > 0) {
+        lines.push(`- ${korean ? "분석 옵션" : "Analysis options"}: ${specification.methodAnalysis.analysisOptions.join("; ")}`);
+    }
+    if (specification.evidenceAccess.requiredSources?.length) {
+        lines.push(`- ${korean ? "필요 근거원" : "Required sources"}: ${specification.evidenceAccess.requiredSources.join("; ")}`);
+    }
+    if (specification.evidenceAccess.accessRequirements?.length) {
+        lines.push(`- ${korean ? "Corpus and Access Plan" : "Corpus and Access Plan"}: ${specification.evidenceAccess.accessRequirements.join("; ")}`);
+    }
+    if (specification.evidenceAccess.evidenceStandards?.length) {
+        lines.push(`- ${korean ? "근거 기준" : "Evidence standards"}: ${specification.evidenceAccess.evidenceStandards.join("; ")}`);
+    }
+    if (specification.epistemicAlignment.conflictResolutionRule) {
+        lines.push(`- ${korean ? "충돌 조정 규칙" : "Conflict rule"}: ${specification.epistemicAlignment.conflictResolutionRule}`);
+    }
+    if (specification.protectedDecisions.length > 0) {
+        lines.push(...specification.protectedDecisions.map((decision) => `- ${korean ? "보호할 결정" : "Protected decision"}: ${decision}`));
+    }
+    if (specification.openQuestions.length > 0) {
+        lines.push(...specification.openQuestions.map((question) => `- ${korean ? "열린 질문" : "Open question"}: ${question}`));
+    }
+    if (specification.nextActions.length > 0) {
+        lines.push(...specification.nextActions.map((action) => `- ${korean ? "다음 행동" : "Next action"}: ${action}`));
+    }
+    return lines;
+}
 function buildCurrentGuide(project, session, recentInvocations = [], pendingQuestions = [], pendingObligations = []) {
     const locale = normalizeLocale(session.locale ?? project.locale);
     const openQuestions = session.openQuestions && session.openQuestions.length > 0
@@ -129,6 +186,7 @@ function buildCurrentGuide(project, session, recentInvocations = [], pendingQues
             ...(session.gapRisk ? [`- 공백/암묵지 위험: ${session.gapRisk}`] : []),
             ...(session.protectedDecision ? [`- 보호할 결정: ${session.protectedDecision}`] : []),
             ...(session.firstResearchShape ? [`- First Research Shape: ${session.firstResearchShape.handle}`] : []),
+            ...(session.researchSpecification ? [`- Research Specification: ${session.researchSpecification.title}`] : []),
             ...(session.startInterview ? [`- start interview: ${session.startInterview.summary}`] : []),
             `- 다음 액션: ${nextAction}`,
             `- 관점: ${session.requestedPerspectives.length > 0 ? session.requestedPerspectives.join(", ") : "auto"}`,
@@ -179,6 +237,7 @@ function buildCurrentGuide(project, session, recentInvocations = [], pendingQues
                     ...session.firstResearchShape.openQuestions.map((question) => `- Open question: ${question}`)
                 ]
                 : []),
+            ...(session.researchSpecification ? renderResearchSpecificationSummary(session.researchSpecification, locale) : []),
             "",
             "## 빠른 시작",
             "- 이 디렉토리에서 `codex`를 엽니다.",
@@ -202,6 +261,7 @@ function buildCurrentGuide(project, session, recentInvocations = [], pendingQues
         ...(session.gapRisk ? [`- Gap/tacit risk: ${session.gapRisk}`] : []),
         ...(session.protectedDecision ? [`- Protected decision: ${session.protectedDecision}`] : []),
         ...(session.firstResearchShape ? [`- First Research Shape: ${session.firstResearchShape.handle}`] : []),
+        ...(session.researchSpecification ? [`- Research Specification: ${session.researchSpecification.title}`] : []),
         ...(session.startInterview ? [`- Start interview: ${session.startInterview.summary}`] : []),
         `- Next action: ${nextAction}`,
         `- Perspectives: ${session.requestedPerspectives.length > 0 ? session.requestedPerspectives.join(", ") : "auto"}`,
@@ -252,6 +312,7 @@ function buildCurrentGuide(project, session, recentInvocations = [], pendingQues
                 ...session.firstResearchShape.openQuestions.map((question) => `- Open question: ${question}`)
             ]
             : []),
+        ...(session.researchSpecification ? renderResearchSpecificationSummary(session.researchSpecification, locale) : []),
         "",
         "## Quick Start",
         "- Open `codex` in this directory.",
@@ -272,6 +333,7 @@ async function loadResearchState(stateFilePath) {
         workingState: parsed.workingState ?? {},
         hooks: parsed.hooks ?? [],
         ...(parsed.firstResearchShape ? { firstResearchShape: parsed.firstResearchShape } : {}),
+        ...(parsed.researchSpecification ? { researchSpecification: parsed.researchSpecification } : {}),
         questionObligations: parsed.questionObligations ?? [],
         inferredHypotheses: parsed.inferredHypotheses ?? [],
         openTensions: parsed.openTensions ?? [],
@@ -332,7 +394,18 @@ function summarizeWorkspaceInspection(context, state) {
             currentGoal: context.session.currentGoal,
             ...(context.session.currentBlocker ? { currentBlocker: context.session.currentBlocker } : {}),
             requestedPerspectives: context.session.requestedPerspectives,
-            disagreementPreference: context.session.disagreementPreference
+            disagreementPreference: context.session.disagreementPreference,
+            ...(context.session.researchSpecification
+                ? {
+                    researchSpecification: {
+                        title: context.session.researchSpecification.title,
+                        status: context.session.researchSpecification.confirmedAt
+                            ? "confirmed"
+                            : context.session.researchSpecification.status ?? "draft",
+                        confidence: context.session.researchSpecification.confidence
+                    }
+                }
+                : {})
         },
         files: {
             project: context.projectFilePath,
@@ -422,6 +495,7 @@ function buildProjectAgentsMd(project, session) {
         "- Begin exploratory work with clarifying or tension questions before recommending a direction.",
         "- For `$longtable-interview`, ask one natural-language question at a time, reflect with `LongTable hears: ...`, record turns when MCP is available, and avoid early reader/reviewer or theory/method/measurement classification.",
         "- Do not summarize `$longtable-interview` because a fixed number of turns has passed; wait for content-based readiness around research object, focal uncertainty, boundary, evidence/material, protected decision, and next action.",
+        "- After the First Research Shape, create a Research Specification when the interview has enough detail to preserve scope, construct ontology, theory framing, coding rules, method options, evidence/access requirements, epistemic alignment, protected decisions, open questions, and next actions.",
         "- Do not let unrelated pending Researcher Checkpoints interrupt `$longtable-interview`; mention them only as separate unresolved checkpoints unless the researcher is confirming, saving, or recording a research decision.",
         "- Use structured options only at the final First Research Shape confirmation or at true checkpoint boundaries.",
         "- If you foreground role perspectives, disclose them with `LongTable consulted: ...`.",
@@ -441,6 +515,7 @@ function buildProjectAgentsMd(project, session) {
         ...(session.gapRisk ? [`- Gap/tacit risk: ${session.gapRisk}`] : []),
         ...(session.protectedDecision ? [`- Protected decision: ${session.protectedDecision}`] : []),
         ...(session.firstResearchShape ? [`- First Research Shape: ${session.firstResearchShape.handle}`] : []),
+        ...(session.researchSpecification ? [`- Research Specification: ${session.researchSpecification.title}`] : []),
         ...(session.startInterview ? [`- Start interview summary: ${session.startInterview.summary}`] : []),
         `- Requested perspectives: ${session.requestedPerspectives.length > 0 ? session.requestedPerspectives.join(", ") : "auto"}`,
         `- Disagreement visibility: ${session.disagreementPreference}`,
@@ -473,6 +548,10 @@ function buildStateSeed(project, session, setup) {
         state.firstResearchShape = session.firstResearchShape;
         state.workingState.firstResearchShape = session.firstResearchShape;
     }
+    if (session.researchSpecification) {
+        state.researchSpecification = session.researchSpecification;
+        state.workingState.researchSpecification = session.researchSpecification;
+    }
     if (session.currentBlocker) {
         state.openTensions.push(session.currentBlocker);
     }
@@ -543,7 +622,16 @@ async function removeLegacyRootFiles(projectPath) {
 }
 export async function syncCurrentWorkspaceView(context) {
     const state = await loadResearchState(context.stateFilePath);
-    const body = buildCurrentGuide(context.project, context.session, recentInvocationRecords(state), recentPendingQuestions(state), recentPendingObligations(state));
+    const session = {
+        ...context.session,
+        ...(context.session.firstResearchShape ?? state.firstResearchShape
+            ? { firstResearchShape: context.session.firstResearchShape ?? state.firstResearchShape }
+            : {}),
+        ...(context.session.researchSpecification ?? state.researchSpecification
+            ? { researchSpecification: context.session.researchSpecification ?? state.researchSpecification }
+            : {})
+    };
+    const body = buildCurrentGuide(context.project, session, recentInvocationRecords(state), recentPendingQuestions(state), recentPendingObligations(state));
     await writeFile(context.currentFilePath, body, "utf8");
     return context.currentFilePath;
 }
@@ -772,6 +860,122 @@ export async function summarizeLongTableInterview(options) {
     await syncCurrentWorkspaceView(options.context);
     return { hook, shape, state: updated, session };
 }
+function normalizeStringArray(values) {
+    return (values ?? []).map((value) => value.trim()).filter(Boolean);
+}
+function normalizeOptionalString(value) {
+    const trimmed = value?.trim();
+    return trimmed && trimmed.length > 0 ? trimmed : undefined;
+}
+function normalizeResearchSpecification(input, sourceHookId, timestamp) {
+    const title = input.title.trim();
+    if (!title) {
+        throw new Error("Research Specification title is required.");
+    }
+    const purpose = input.researchDirection.purpose.trim();
+    if (!purpose) {
+        throw new Error("Research Specification researchDirection.purpose is required.");
+    }
+    return {
+        title,
+        status: input.confirmedAt ? "confirmed" : input.status ?? "draft",
+        createdAt: input.createdAt ?? timestamp,
+        updatedAt: timestamp,
+        ...(sourceHookId ? { sourceHookId } : {}),
+        researchDirection: {
+            ...(normalizeOptionalString(input.researchDirection.question) ? { question: normalizeOptionalString(input.researchDirection.question) } : {}),
+            purpose,
+            ...(normalizeOptionalString(input.researchDirection.scopeBoundary) ? { scopeBoundary: normalizeOptionalString(input.researchDirection.scopeBoundary) } : {}),
+            inclusionCriteria: normalizeStringArray(input.researchDirection.inclusionCriteria),
+            exclusionCriteria: normalizeStringArray(input.researchDirection.exclusionCriteria)
+        },
+        constructOntology: {
+            coreConstructs: normalizeStringArray(input.constructOntology.coreConstructs),
+            distinctions: normalizeStringArray(input.constructOntology.distinctions),
+            termsToAvoidCollapsing: normalizeStringArray(input.constructOntology.termsToAvoidCollapsing)
+        },
+        theoryAndFraming: {
+            anchors: normalizeStringArray(input.theoryAndFraming.anchors),
+            alternatives: normalizeStringArray(input.theoryAndFraming.alternatives),
+            overreachRisks: normalizeStringArray(input.theoryAndFraming.overreachRisks)
+        },
+        measurementCoding: {
+            variablesOrConstructs: normalizeStringArray(input.measurementCoding.variablesOrConstructs),
+            evidenceTypes: normalizeStringArray(input.measurementCoding.evidenceTypes),
+            codingRules: normalizeStringArray(input.measurementCoding.codingRules),
+            openStandards: normalizeStringArray(input.measurementCoding.openStandards)
+        },
+        methodAnalysis: {
+            ...(normalizeOptionalString(input.methodAnalysis.design) ? { design: normalizeOptionalString(input.methodAnalysis.design) } : {}),
+            analysisOptions: normalizeStringArray(input.methodAnalysis.analysisOptions),
+            dataSufficiencyCriteria: normalizeStringArray(input.methodAnalysis.dataSufficiencyCriteria),
+            unsettledChoices: normalizeStringArray(input.methodAnalysis.unsettledChoices)
+        },
+        evidenceAccess: {
+            requiredSources: normalizeStringArray(input.evidenceAccess.requiredSources),
+            accessRequirements: normalizeStringArray(input.evidenceAccess.accessRequirements),
+            evidenceStandards: normalizeStringArray(input.evidenceAccess.evidenceStandards)
+        },
+        epistemicAlignment: {
+            researcherKnowledge: normalizeStringArray(input.epistemicAlignment.researcherKnowledge),
+            projectStatePriority: normalizeStringArray(input.epistemicAlignment.projectStatePriority),
+            aiInferenceLimits: normalizeStringArray(input.epistemicAlignment.aiInferenceLimits),
+            ...(normalizeOptionalString(input.epistemicAlignment.conflictResolutionRule)
+                ? { conflictResolutionRule: normalizeOptionalString(input.epistemicAlignment.conflictResolutionRule) }
+                : {})
+        },
+        protectedDecisions: normalizeStringArray(input.protectedDecisions),
+        openQuestions: normalizeStringArray(input.openQuestions),
+        nextActions: normalizeStringArray(input.nextActions),
+        confidence: input.confidence,
+        ...(input.confirmedAt ? { confirmedAt: input.confirmedAt } : {})
+    };
+}
+export async function summarizeLongTableResearchSpecification(options) {
+    const state = await loadResearchState(options.context.stateFilePath);
+    const sourceHookId = options.hookId
+        ?? options.specification.sourceHookId
+        ?? state.firstResearchShape?.sourceHookId;
+    const existing = sourceHookId
+        ? (state.hooks ?? []).find((hook) => hook.id === sourceHookId)
+        : activeInterviewHook(state);
+    const timestamp = nowIso();
+    const specification = normalizeResearchSpecification(options.specification, existing?.id ?? sourceHookId, timestamp);
+    const hook = existing
+        ? {
+            ...existing,
+            status: "ready_to_confirm",
+            updatedAt: timestamp,
+            researchSpecification: specification
+        }
+        : undefined;
+    const session = {
+        ...options.context.session,
+        lastUpdatedAt: timestamp,
+        researchSpecification: specification,
+        resumeHint: `I want to continue from the Research Specification: ${specification.title}.`
+    };
+    options.context.session = session;
+    let updated = hook ? upsertHook(state, hook) : state;
+    updated.researchSpecification = specification;
+    updated.workingState = {
+        ...updated.workingState,
+        researchSpecification: specification
+    };
+    updated.narrativeTraces.push({
+        id: createId("narrative_trace"),
+        timestamp,
+        source: "$longtable-interview",
+        traceType: "judgment",
+        summary: `Research Specification draft: ${specification.title}.`,
+        visibility: "explicit",
+        importance: specification.confidence
+    });
+    await writeFile(options.context.sessionFilePath, JSON.stringify(session, null, 2), "utf8");
+    await writeFile(options.context.stateFilePath, JSON.stringify(updated, null, 2), "utf8");
+    await syncCurrentWorkspaceView(options.context);
+    return { hook, specification, state: updated, session };
+}
 function findQuestionForDecision(state, questionId) {
     const pending = (state.questionLog ?? []).filter((record) => record.status === "pending");
     if (questionId) {
@@ -1024,8 +1228,8 @@ function questionPriority(spec) {
     const requiredWeight = spec.kind === "research_commitment" || spec.required ? 20 : 0;
     return (byKey[spec.key] ?? 0) + confidenceWeight + requiredWeight;
 }
-function followUpQuestionOptions(first, second, third, fourth) {
-    return [first, second, third, ...(fourth ? [fourth] : [])];
+function followUpQuestionOptions(first, second, third, ...rest) {
+    return [first, second, third, ...rest];
 }
 export function buildQuestionOpportunitySpecs(prompt, options = {}) {
     const normalized = prompt.toLowerCase();
@@ -1090,8 +1294,26 @@ export function buildQuestionOpportunitySpecs(prompt, options = {}) {
         /\brandom[- ]?effects\b/i,
         /분석\s*계획|분석\s*방법|메타\s*분석|분석\s*(?:모형|모델)|통계\s*(?:모형|모델)|구조\s*방정식|경로\s*모형|조절효과|랜덤\s*효과/
     ]);
+    const accessCue = includesAny(normalized, [
+        /\b(pdf|full[- ]?text|tdm|publisher api|institutional access|library login|vpn|proxy|subscription|paper collection|source collection|corpus|download)\b/i,
+        /PDF|원문|전문|기관\s*구독|기관구독|구독|VPN|프록시|도서관|라이브러리|TDM|논문\s*수집|문헌\s*수집|코퍼스|다운로드/
+    ]);
     const decisionFamilyCount = [scopeCue, theoryCue, measurementCodingCue, methodCue, analysisCue]
         .filter(Boolean).length;
+    if (accessCue) {
+        push({
+            key: "scholarly_access_policy",
+            kind: "evidence_risk",
+            title: "Scholarly access policy",
+            question: "What scholarly access route should LongTable use before collecting PDFs, full text, or subscription-only evidence?",
+            whyNow: "Full-text access decisions can change the corpus, inclusion bias, reproducibility, and TDM permission boundary.",
+            options: followUpQuestionOptions({ value: "oa_only", label: "OA-only", description: "Use only open-access PDF or full text.", recommended: true }, { value: "institutional_access", label: "Institutional access", description: "Include VPN/proxy/library-login access after the researcher completes login." }, { value: "publisher_tdm", label: "Publisher API/TDM", description: "Use configured publisher API/TDM credentials and record entitlement checks." }, { value: "manual_pdf", label: "Manual PDFs", description: "Use PDFs supplied by the researcher and record provenance." }, { value: "metadata_only", label: "Metadata only", description: "Do not collect full text yet." }),
+            confidence: "high",
+            autoEligible: true,
+            required: true,
+            cues: ["scholarly_access", "full_text", "corpus"]
+        });
+    }
     if (decisionActionCue && decisionFamilyCount >= 2) {
         push({
             key: "research_direction_change_commitment",
@@ -1424,7 +1646,7 @@ export function buildQuestionOpportunitySpecs(prompt, options = {}) {
     }
     let selected = options.autoOnly === true ? specs.filter((spec) => spec.autoEligible) : specs;
     if (options.requiredOnly === true) {
-        selected = selected.filter((spec) => spec.kind === "research_commitment");
+        selected = selected.filter((spec) => spec.kind === "research_commitment" || spec.required);
     }
     if (normalized.includes("protected decision closure pressure")) {
         selected = selected.filter((spec) => spec.key === "protected_decision_closure");

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

@@ -1,4 +1,4 @@
-import { type CrossrefTdmDiscovery, type EvidenceCard, type Publisher, type PublisherAccessRecord, type PublisherProbeInput, type PublisherProbeTarget, type SearchCapabilitySnapshot, type SearchFetch } from "./types.js";
+import { type CrossrefTdmDiscovery, type EvidenceCard, type Publisher, type PublisherAccessRecord, type PublisherProbeInput, type PublisherProbeTarget, type SearchFetch } from "./types.js";
 interface PublisherConfig {
     publisher: Publisher;
     label: string;
@@ -12,8 +12,6 @@ export declare function discoverCrossrefTdm(doi: string, env?: Record<string, st
 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>;

package/dist/search/publisher-access.js

@@ -1,5 +1,3 @@
-import { join } from "node:path";
-import { homedir } from "node:os";
 import { PUBLISHERS } from "./types.js";
 const PUBLISHER_CONFIGS = {
     elsevier: {
@@ -505,17 +503,6 @@ export function summarizeConfiguredPublisherAccess(env = process.env) {
         });
     });
 }
-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";

package/dist/search/types.d.ts

@@ -173,12 +173,6 @@ export interface PublisherAccessRecord {
     evidenceSnippet?: string;
     crossref?: CrossrefTdmDiscovery;
 }
-export interface SearchCapabilitySnapshot {
-    version: 1;
-    updatedAt: string;
-    contactEmailPresent: boolean;
-    records: PublisherAccessRecord[];
-}
 export interface PublisherProbeInput {
     doi: string;
     publisher?: PublisherProbeTarget;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@longtable/cli",
-  "version": "0.1.43",
+  "version": "0.1.45",
   "private": false,
   "description": "Researcher-facing LongTable CLI",
   "type": "module",
@@ -29,12 +29,12 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.2.0",
-    "@longtable/checkpoints": "0.1.43",
-    "@longtable/core": "0.1.43",
-    "@longtable/memory": "0.1.43",
-    "@longtable/provider-claude": "0.1.43",
-    "@longtable/provider-codex": "0.1.43",
-    "@longtable/setup": "0.1.43"
+    "@longtable/checkpoints": "0.1.45",
+    "@longtable/core": "0.1.45",
+    "@longtable/memory": "0.1.45",
+    "@longtable/provider-claude": "0.1.45",
+    "@longtable/provider-codex": "0.1.45",
+    "@longtable/setup": "0.1.45"
   },
   "devDependencies": {
     "@types/node": "^22.10.1",