@longtable/cli 0.1.9 → 0.1.10

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./prompt-aliases.js";
 export * from "./personas.js";
 export * from "./persona-router.js";
+export * from "./panel.js";

package/dist/index.js

@@ -1,3 +1,4 @@
 export * from "./prompt-aliases.js";
 export * from "./personas.js";
 export * from "./persona-router.js";
+export * from "./panel.js";

package/dist/panel.d.ts

@@ -0,0 +1,40 @@
+import type { CheckpointSensitivity, InteractionMode, InvocationIntent, InvocationRecord, PanelPlan, PanelResult, PanelVisibility, QuestionRecord, ProviderKind, RoleKey } from "@longtable/core";
+import { type CanonicalPersona } from "./personas.js";
+export interface BuildPanelPlanOptions {
+    prompt: string;
+    mode?: InteractionMode;
+    roleFlag?: string;
+    roles?: CanonicalPersona[];
+    provider?: ProviderKind;
+    visibility?: PanelVisibility;
+}
+export interface PanelFallback {
+    intent: InvocationIntent;
+    plan: PanelPlan;
+    result: PanelResult;
+    invocationRecord: InvocationRecord;
+    questionRecord: QuestionRecord;
+    prompt: string;
+}
+export declare function buildPanelPlan(options: BuildPanelPlanOptions): PanelPlan;
+export declare function buildInvocationIntent(options: {
+    prompt: string;
+    mode?: InteractionMode;
+    roles: RoleKey[];
+    provider?: ProviderKind;
+    visibility?: PanelVisibility;
+    checkpointSensitivity?: CheckpointSensitivity;
+    rationale?: string[];
+}): InvocationIntent;
+export declare function createPlannedPanelQuestionRecord(plan: PanelPlan, provider?: ProviderKind): QuestionRecord;
+export declare function createPlannedPanelResult(plan: PanelPlan, provider?: ProviderKind, linkedQuestionRecordIds?: string[]): PanelResult;
+export declare function createPlannedInvocationRecord(options: {
+    intent: InvocationIntent;
+    plan: PanelPlan;
+    result: PanelResult;
+    provider?: ProviderKind;
+}): InvocationRecord;
+export declare function renderSequentialFallbackPrompt(plan: PanelPlan): string;
+export declare function buildPanelFallback(options: BuildPanelPlanOptions): PanelFallback;
+export declare function renderPanelSummary(plan: PanelPlan): string;
+export declare function listDefaultPanelRoles(): CanonicalPersona[];

package/dist/panel.js

@@ -0,0 +1,268 @@
+import { getPersonaDefinition, parsePersonaKey, PERSONA_DEFINITIONS } from "./personas.js";
+import { detectOutputLanguage, parseRoleFlag, routePersonas } from "./persona-router.js";
+const DEFAULT_PANEL_ROLES = [
+    "reviewer",
+    "methods_critic",
+    "measurement_auditor",
+    "theory_critic"
+];
+function unique(items) {
+    return [...new Set(items)];
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+function createId(prefix) {
+    return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function highestSensitivity(keys) {
+    if (keys.some((key) => getPersonaDefinition(key).checkpointSensitivity === "high")) {
+        return "high";
+    }
+    if (keys.some((key) => getPersonaDefinition(key).checkpointSensitivity === "medium")) {
+        return "medium";
+    }
+    return "low";
+}
+function supportsMode(key, mode) {
+    return getPersonaDefinition(key).supportedModes.includes(mode);
+}
+function reasonForRole(key, explicitRoles, routedRoles) {
+    if (explicitRoles.includes(key)) {
+        return "explicitly requested";
+    }
+    if (routedRoles.includes(key)) {
+        return "matched prompt language";
+    }
+    if (DEFAULT_PANEL_ROLES.includes(key)) {
+        return "default panel member";
+    }
+    return "panel support role";
+}
+function resolvePanelRoles(options) {
+    const mode = options.mode ?? "review";
+    const explicitFromFlag = parseRoleFlag(options.roleFlag);
+    const explicitRoles = unique([...(options.roles ?? []), ...explicitFromFlag]);
+    if (explicitRoles.length > 0) {
+        return explicitRoles.filter((role) => supportsMode(role, mode));
+    }
+    const routed = routePersonas(options.prompt).consultedRoles.filter((role) => supportsMode(role, mode));
+    return unique([
+        ...DEFAULT_PANEL_ROLES.filter((role) => supportsMode(role, mode)),
+        ...routed
+    ]);
+}
+function memberForRole(role, explicitRoles, routedRoles) {
+    const definition = getPersonaDefinition(role);
+    return {
+        role,
+        label: definition.label,
+        reason: reasonForRole(role, explicitRoles, routedRoles),
+        required: DEFAULT_PANEL_ROLES.includes(role) || explicitRoles.includes(role)
+    };
+}
+export function buildPanelPlan(options) {
+    const mode = options.mode ?? "review";
+    const explicitRoles = unique([...(options.roles ?? []), ...parseRoleFlag(options.roleFlag)]);
+    const routedRoles = routePersonas(options.prompt).consultedRoles;
+    const roles = resolvePanelRoles(options);
+    const createdAt = nowIso();
+    return {
+        id: createId("panel_plan"),
+        createdAt,
+        mode,
+        prompt: options.prompt,
+        members: roles.map((role) => memberForRole(role, explicitRoles, routedRoles)),
+        visibility: options.visibility ?? "always_visible",
+        preferredSurface: "sequential_fallback",
+        fallbackSurface: "sequential_fallback",
+        checkpointSensitivity: highestSensitivity(roles),
+        rationale: [
+            "Option A uses provider-neutral panel semantics before native provider orchestration.",
+            "Sequential fallback is the stable execution path for both Claude Code and Codex.",
+            roles.length === explicitRoles.length && explicitRoles.length > 0
+                ? "The panel is constrained by explicitly requested roles."
+                : "The panel combines default research-review roles with prompt-triggered roles."
+        ]
+    };
+}
+export function buildInvocationIntent(options) {
+    return {
+        id: createId("invocation"),
+        kind: "panel",
+        mode: options.mode ?? "review",
+        prompt: options.prompt,
+        roles: options.roles,
+        provider: options.provider,
+        requestedSurface: "sequential_fallback",
+        visibility: options.visibility ?? "always_visible",
+        checkpointSensitivity: options.checkpointSensitivity ?? "medium",
+        rationale: options.rationale ?? ["Panel invocation requested."]
+    };
+}
+export function createPlannedPanelQuestionRecord(plan, provider) {
+    const createdAt = nowIso();
+    return {
+        id: createId("question_record"),
+        createdAt,
+        updatedAt: createdAt,
+        status: "pending",
+        prompt: {
+            id: createId("question_prompt"),
+            checkpointKey: "panel_next_decision",
+            title: "Panel follow-up decision",
+            question: "What should LongTable treat as the next human decision after this panel review?",
+            type: "single_choice",
+            options: [
+                {
+                    value: "revise",
+                    label: "Revise before proceeding",
+                    description: "Use the panel result to revise the claim, design, or draft first."
+                },
+                {
+                    value: "evidence",
+                    label: "Gather or verify evidence first",
+                    description: "Do not proceed until the relevant evidence or citation support is checked."
+                },
+                {
+                    value: "proceed",
+                    label: "Proceed with current direction",
+                    description: "Accept the risk profile and continue with the current direction."
+                },
+                {
+                    value: "defer",
+                    label: "Keep this open",
+                    description: "Do not commit yet; keep the panel issue visible as an open tension."
+                }
+            ],
+            allowOther: true,
+            otherLabel: "Other decision",
+            required: plan.checkpointSensitivity === "high",
+            source: "runtime_guidance",
+            rationale: [
+                "Panel review creates disagreement or risk visibility that should connect to an explicit researcher decision.",
+                `Panel checkpoint sensitivity: ${plan.checkpointSensitivity}.`
+            ],
+            preferredSurfaces: provider === "claude"
+                ? ["native_structured", "numbered"]
+                : ["numbered", "native_structured"]
+        }
+    };
+}
+export function createPlannedPanelResult(plan, provider, linkedQuestionRecordIds = []) {
+    const createdAt = nowIso();
+    return {
+        id: createId("panel_result"),
+        planId: plan.id,
+        createdAt,
+        updatedAt: createdAt,
+        provider,
+        surface: "sequential_fallback",
+        status: "planned",
+        memberResults: plan.members.map((member) => ({
+            role: member.role,
+            label: member.label,
+            status: "planned"
+        })),
+        linkedQuestionRecordIds,
+        linkedDecisionRecordIds: []
+    };
+}
+export function createPlannedInvocationRecord(options) {
+    const createdAt = nowIso();
+    return {
+        id: createId("invocation_record"),
+        createdAt,
+        updatedAt: createdAt,
+        intent: options.intent,
+        status: "planned",
+        provider: options.provider,
+        surface: "sequential_fallback",
+        panelPlan: options.plan,
+        panelResult: options.result,
+        degradationReason: "Native provider team execution is optional; sequential fallback is the stable LongTable surface."
+    };
+}
+function roleInstruction(member) {
+    const key = parsePersonaKey(member.role);
+    const definition = key ? getPersonaDefinition(key) : null;
+    return [
+        `Role: ${member.label} (${member.role})`,
+        `Reason: ${member.reason}.`,
+        definition ? `Focus: ${definition.shortDescription}` : undefined,
+        "Output: claims, objections, open questions, and evidence/file references when available."
+    ].filter(Boolean).join("\n");
+}
+function languageNote(language) {
+    return language === "ko"
+        ? "Respond in Korean unless the research artifact itself requires English."
+        : "Respond in the user's language unless the research artifact requires another language.";
+}
+export function renderSequentialFallbackPrompt(plan) {
+    const language = detectOutputLanguage(plan.prompt);
+    return [
+        "LongTable mode: Panel",
+        "Execution surface: sequential_fallback",
+        "",
+        "Run this as a structured panel review. Treat each role as an independent pass, then synthesize.",
+        "Do not expose hidden reasoning, private tool traces, or provider chain-of-thought.",
+        "Make disagreement inspectable through structured role outputs.",
+        languageNote(language),
+        "",
+        "Panel roles:",
+        ...plan.members.map((member, index) => `${index + 1}. ${roleInstruction(member)}`),
+        "",
+        "Return format:",
+        "1. LongTable synthesis",
+        "2. Panel opinions by role",
+        "3. Conflict summary",
+        "4. Decision prompt for the researcher",
+        "5. Technical record: roles consulted, execution surface, fallback/native mode, and source/file references used",
+        "",
+        "Research object:",
+        plan.prompt
+    ].join("\n");
+}
+export function buildPanelFallback(options) {
+    const plan = buildPanelPlan(options);
+    const intent = buildInvocationIntent({
+        prompt: plan.prompt,
+        mode: plan.mode,
+        roles: plan.members.map((member) => member.role),
+        provider: options.provider,
+        visibility: plan.visibility,
+        checkpointSensitivity: plan.checkpointSensitivity,
+        rationale: plan.rationale
+    });
+    const questionRecord = createPlannedPanelQuestionRecord(plan, options.provider);
+    const result = createPlannedPanelResult(plan, options.provider, [questionRecord.id]);
+    return {
+        intent,
+        plan,
+        result,
+        invocationRecord: createPlannedInvocationRecord({
+            intent,
+            plan,
+            result,
+            provider: options.provider
+        }),
+        questionRecord,
+        prompt: renderSequentialFallbackPrompt(plan)
+    };
+}
+export function renderPanelSummary(plan) {
+    return [
+        "LongTable Panel Plan",
+        `- mode: ${plan.mode}`,
+        `- execution surface: ${plan.preferredSurface}`,
+        `- visibility: ${plan.visibility}`,
+        `- checkpoint sensitivity: ${plan.checkpointSensitivity}`,
+        "- roles:",
+        ...plan.members.map((member) => `  - ${member.label} (${member.role}): ${member.reason}`),
+        "",
+        "This is panel orchestration, not persistent team orchestration."
+    ].join("\n");
+}
+export function listDefaultPanelRoles() {
+    return PERSONA_DEFINITIONS.filter((persona) => persona.defaultPanelMember).map((persona) => persona.key);
+}

package/dist/personas.d.ts

@@ -1,3 +1,4 @@
+import type { CheckpointSensitivity, InteractionMode, RoleDefinition } from "@longtable/core";
 export declare const CANONICAL_PERSONAS: readonly ["editor", "reviewer", "theory_critic", "methods_critic", "measurement_auditor", "ethics_reviewer", "voice_keeper", "venue_strategist"];
 export type CanonicalPersona = (typeof CANONICAL_PERSONAS)[number];
 export interface PersonaDefinition {
@@ -6,7 +7,11 @@ export interface PersonaDefinition {
     shortDescription: string;
     triggerMode: "auto-callable" | "explicit-only";
     synonyms: string[];
+    defaultPanelMember: boolean;
+    checkpointSensitivity: CheckpointSensitivity;
+    supportedModes: InteractionMode[];
 }
 export declare const PERSONA_DEFINITIONS: readonly PersonaDefinition[];
 export declare function parsePersonaKey(value: string): CanonicalPersona | null;
 export declare function getPersonaDefinition(key: CanonicalPersona): PersonaDefinition;
+export declare function listRoleDefinitions(): RoleDefinition[];

package/dist/personas.js

@@ -14,28 +14,40 @@ export const PERSONA_DEFINITIONS = [
         label: "Journal Editor",
         shortDescription: "Assesses venue fit, framing strength, and editorial salience.",
         triggerMode: "auto-callable",
-        synonyms: ["editor", "journal editor", "editorial", "편집자", "저널 편집자", "에디터"]
+        synonyms: ["editor", "journal editor", "editorial", "편집자", "저널 편집자", "에디터"],
+        defaultPanelMember: false,
+        checkpointSensitivity: "medium",
+        supportedModes: ["review", "critique", "draft", "commit", "submit"]
     },
     {
         key: "reviewer",
         label: "Reviewer",
         shortDescription: "Surfaces likely peer-review objections and requests for clarification.",
         triggerMode: "auto-callable",
-        synonyms: ["reviewer", "peer reviewer", "심사자", "리뷰어", "심사위원"]
+        synonyms: ["reviewer", "peer reviewer", "심사자", "리뷰어", "심사위원"],
+        defaultPanelMember: true,
+        checkpointSensitivity: "medium",
+        supportedModes: ["review", "critique", "draft", "commit", "submit"]
     },
     {
         key: "theory_critic",
         label: "Theory Critic",
         shortDescription: "Checks conceptual coherence, anchor theory fit, and overreach.",
         triggerMode: "auto-callable",
-        synonyms: ["theory", "theoretical", "conceptual", "이론", "이론적", "개념적"]
+        synonyms: ["theory", "theoretical", "conceptual", "이론", "이론적", "개념적"],
+        defaultPanelMember: true,
+        checkpointSensitivity: "high",
+        supportedModes: ["explore", "review", "critique", "draft", "commit", "submit"]
     },
     {
         key: "methods_critic",
         label: "Methods Critic",
         shortDescription: "Challenges design logic, methodological defensibility, and alignment.",
         triggerMode: "auto-callable",
-        synonyms: ["method", "methods", "methodology", "research design", "방법론", "방법", "연구 설계"]
+        synonyms: ["method", "methods", "methodology", "research design", "방법론", "방법", "연구 설계"],
+        defaultPanelMember: true,
+        checkpointSensitivity: "high",
+        supportedModes: ["explore", "review", "critique", "draft", "commit", "submit"]
     },
     {
         key: "measurement_auditor",
@@ -52,28 +64,40 @@ export const PERSONA_DEFINITIONS = [
             "척도",
             "타당도",
             "신뢰도"
-        ]
+        ],
+        defaultPanelMember: true,
+        checkpointSensitivity: "high",
+        supportedModes: ["review", "critique", "commit", "submit"]
     },
     {
         key: "ethics_reviewer",
         label: "Ethics Reviewer",
         shortDescription: "Flags consent, IRB, representation, and trust harms.",
         triggerMode: "auto-callable",
-        synonyms: ["ethics", "ethical", "irb", "윤리", "윤리적", "irb"]
+        synonyms: ["ethics", "ethical", "irb", "윤리", "윤리적", "irb"],
+        defaultPanelMember: false,
+        checkpointSensitivity: "high",
+        supportedModes: ["explore", "review", "critique", "commit", "submit"]
     },
     {
         key: "voice_keeper",
         label: "Voice Keeper",
         shortDescription: "Protects narrative trace, authorship, and the researcher's own voice.",
         triggerMode: "auto-callable",
-        synonyms: ["voice", "tone", "narrative", "authorship", "목소리", "서사", "저자성", "문체"]
+        synonyms: ["voice", "tone", "narrative", "authorship", "목소리", "서사", "저자성", "문체"],
+        defaultPanelMember: false,
+        checkpointSensitivity: "medium",
+        supportedModes: ["explore", "review", "critique", "draft", "commit"]
     },
     {
         key: "venue_strategist",
         label: "Venue Strategist",
         shortDescription: "Compares venue expectations and suggests positioning tradeoffs.",
         triggerMode: "explicit-only",
-        synonyms: ["venue", "journal fit", "conference fit", "저널 적합성", "학회 적합성", "투고처"]
+        synonyms: ["venue", "journal fit", "conference fit", "저널 적합성", "학회 적합성", "투고처"],
+        defaultPanelMember: false,
+        checkpointSensitivity: "medium",
+        supportedModes: ["review", "critique", "draft", "commit", "submit"]
     }
 ];
 export function parsePersonaKey(value) {
@@ -85,3 +109,15 @@ export function parsePersonaKey(value) {
 export function getPersonaDefinition(key) {
     return PERSONA_DEFINITIONS.find((persona) => persona.key === key);
 }
+export function listRoleDefinitions() {
+    return PERSONA_DEFINITIONS.map((persona) => ({
+        key: persona.key,
+        label: persona.label,
+        shortDescription: persona.shortDescription,
+        triggerMode: persona.triggerMode,
+        synonyms: [...persona.synonyms],
+        defaultPanelMember: persona.defaultPanelMember,
+        checkpointSensitivity: persona.checkpointSensitivity,
+        supportedModes: [...persona.supportedModes]
+    }));
+}

package/dist/project-session.d.ts

@@ -1,3 +1,4 @@
+import type { DecisionRecord, InvocationRecord, ProviderKind, QuestionRecord, ResearchState } from "@longtable/core";
 import type { SetupPersistedOutput } from "@longtable/setup";
 export type ProjectDisagreementPreference = "synthesis_only" | "show_on_conflict" | "always_visible";
 export interface LongTableProjectRecord {
@@ -44,7 +45,86 @@ export interface LongTableProjectContext {
     currentFilePath: string;
     metaDir: string;
 }
+export interface LongTableWorkspaceInspection {
+    found: boolean;
+    rootPath?: string;
+    project?: {
+        name: string;
+        path: string;
+        field: string;
+        careerStage: string;
+        checkpointIntensity: string;
+    };
+    session?: {
+        currentGoal: string;
+        currentBlocker?: string;
+        requestedPerspectives: string[];
+        disagreementPreference: ProjectDisagreementPreference;
+    };
+    files?: {
+        project: string;
+        session: string;
+        state: string;
+        current: string;
+    };
+    counts?: {
+        invocations: number;
+        questions: number;
+        pendingQuestions: number;
+        answeredQuestions: number;
+        decisions: number;
+    };
+    recentInvocations?: Array<{
+        id: string;
+        kind: string;
+        mode: string;
+        surface: string;
+        status: string;
+        roles: string[];
+        linkedQuestions: number;
+        linkedDecisions: number;
+    }>;
+    pendingQuestions?: Array<{
+        id: string;
+        title: string;
+        question: string;
+        options: string[];
+        required: boolean;
+    }>;
+    recentDecisions?: Array<{
+        id: string;
+        checkpointKey: string;
+        summary: string;
+        selectedOption?: string;
+        timestamp: string;
+    }>;
+}
 export declare function syncCurrentWorkspaceView(context: LongTableProjectContext): Promise<string>;
+export declare function appendInvocationRecordToWorkspace(context: LongTableProjectContext, invocation: InvocationRecord, questions?: QuestionRecord[]): Promise<ResearchState>;
+export declare function listBlockingWorkspaceQuestions(context: LongTableProjectContext): Promise<QuestionRecord[]>;
+export declare function assertWorkspaceNotBlocked(context: LongTableProjectContext): Promise<void>;
+export declare function createWorkspaceQuestion(options: {
+    context: LongTableProjectContext;
+    prompt: string;
+    title?: string;
+    question?: string;
+    provider?: ProviderKind;
+    required?: boolean;
+}): Promise<{
+    question: QuestionRecord;
+    state: ResearchState;
+}>;
+export declare function answerWorkspaceQuestion(options: {
+    context: LongTableProjectContext;
+    questionId?: string;
+    answer: string;
+    rationale?: string;
+    provider?: "codex" | "claude";
+}): Promise<{
+    question: QuestionRecord;
+    decision: DecisionRecord;
+    state: ResearchState;
+}>;
 export declare function createOrUpdateProjectWorkspace(options: {
     projectName: string;
     projectPath: string;
@@ -55,4 +135,5 @@ export declare function createOrUpdateProjectWorkspace(options: {
     setup: SetupPersistedOutput;
 }): Promise<LongTableProjectContext>;
 export declare function loadProjectContextFromDirectory(startPath: string): Promise<LongTableProjectContext | null>;
+export declare function inspectProjectWorkspace(startPath: string): Promise<LongTableWorkspaceInspection>;
 export declare function renderProjectWorkspaceSummary(context: LongTableProjectContext): string;