@unson/brainbase-mcp 0.43.0 → 0.44.1

package/dist/meeting-automation-runtime.d.ts

@@ -0,0 +1,102 @@
+import { verifyMeetingReviewPackage, type MeetingReviewPackage, type VerifiedMeetingReviewPackage } from './meeting-automation.js';
+export declare const MEETING_AUTOMATION_RUNTIME_VERSION: "brainbase.meeting-automation-runtime.v1";
+type UnknownRecord = Record<string, unknown>;
+type MaybePromise<T> = T | Promise<T>;
+export interface MeetingAutomationRuntimeInput {
+    readonly org_id: string;
+    readonly project_id: string;
+    readonly review_package: MeetingReviewPackage;
+    readonly loop_intent_repository: Parameters<typeof verifyMeetingReviewPackage>[0]['repository'];
+    readonly source_event?: UnknownRecord;
+    readonly case_scope?: string | null;
+    readonly actor_id?: string | null;
+    readonly idempotency_key?: string | null;
+    readonly evidence_refs?: readonly unknown[];
+}
+export interface MeetingAutomationRuntimeRecord {
+    readonly record_id: string;
+    readonly idempotency_key: string;
+    /** Fingerprint of the normalized package before owner resolution. */
+    readonly input_fingerprint?: string;
+    readonly fingerprint: string;
+    readonly org_id: string;
+    readonly project_id: string;
+    readonly state: 'waiting_human';
+    readonly review_package: UnknownRecord;
+    readonly verified_loop_intents: readonly string[];
+    readonly created_at: string;
+    readonly actor_id: string | null;
+}
+export interface MeetingAutomationRuntimeExecution {
+    readonly record: MeetingAutomationRuntimeRecord;
+    readonly attempts: number;
+    readonly workflow: UnknownRecord | null;
+    readonly knowledge: UnknownRecord | null;
+}
+export interface MeetingAutomationRuntimeClaimRequest {
+    readonly idempotency_key: string;
+    readonly fingerprint: string;
+    readonly scope: {
+        readonly org_id: string;
+        readonly project_id: string;
+    };
+    readonly execute: () => MaybePromise<MeetingAutomationRuntimeExecution>;
+}
+export interface MeetingAutomationRuntimeClaimResult {
+    readonly status: 'persisted' | 'replayed';
+    readonly execution: MeetingAutomationRuntimeExecution;
+}
+export interface MeetingAutomationRuntimePorts {
+    readonly ledger: {
+        /**
+         * Atomically claims an idempotency key, executes the complete workflow,
+         * and returns the durable execution on both the winner and replayers.
+         * The host must back this with a durable transaction/claim, not a local
+         * in-memory lock.
+         */
+        readonly claimOrReplay: (request: MeetingAutomationRuntimeClaimRequest) => MaybePromise<MeetingAutomationRuntimeClaimResult>;
+        findByIdempotencyKey?: (key: string, scope: {
+            org_id: string;
+            project_id: string;
+        }) => MaybePromise<MeetingAutomationRuntimeRecord | null>;
+        save: (record: MeetingAutomationRuntimeRecord) => MaybePromise<MeetingAutomationRuntimeRecord | void>;
+        readonly readback: (recordId: string, scope: {
+            org_id: string;
+            project_id: string;
+        }) => MaybePromise<MeetingAutomationRuntimeRecord | null>;
+    };
+    readonly resolveTaskOwners?: (input: UnknownRecord, context: UnknownRecord) => MaybePromise<UnknownRecord>;
+    readonly prepareWorkflow?: (input: UnknownRecord) => MaybePromise<UnknownRecord | void>;
+    readonly bridgeKnowledge?: (input: UnknownRecord) => MaybePromise<UnknownRecord | void>;
+    /**
+     * The host implements this with a durable post-commit outbox/effect ledger.
+     * It must persist the effect key across worker restarts; a process-local
+     * mutex is not sufficient for knowledge bridge idempotency.
+     */
+    readonly runOnce?: <T>(effectKey: string, effect: () => MaybePromise<T>) => MaybePromise<T>;
+    readonly now?: () => Date;
+    readonly max_attempts?: number;
+    readonly is_retryable?: (error: unknown) => boolean;
+}
+export declare class MeetingAutomationRuntimeError extends Error {
+    readonly code: string;
+    readonly details: UnknownRecord;
+    constructor(code: string, message: string, details?: UnknownRecord);
+}
+export interface MeetingAutomationRuntimeResult {
+    readonly status: 'persisted' | 'replayed';
+    readonly idempotent: boolean;
+    readonly attempts: number;
+    readonly record: MeetingAutomationRuntimeRecord;
+    readonly readback: MeetingAutomationRuntimeRecord;
+    readonly verified: VerifiedMeetingReviewPackage;
+    readonly workflow: UnknownRecord | null;
+    readonly knowledge: UnknownRecord | null;
+}
+/**
+ * Provider-independent orchestration for meeting review package ingestion.
+ * The host owns workflow, Graph, identity and durable ledger ports; this core
+ * owns validation, normalization, replay keys, retry and persisted readback.
+ */
+export declare function runMeetingAutomationRuntime(input: MeetingAutomationRuntimeInput, ports: MeetingAutomationRuntimePorts): Promise<MeetingAutomationRuntimeResult>;
+export {};

package/dist/meeting-automation-runtime.js

@@ -0,0 +1,249 @@
+import { createHash } from 'node:crypto';
+import { assertMeetingCandidatesInput, normalizeDecisionCandidates, normalizeFollowUpDraft, normalizeTaskCandidates, verifyMeetingReviewPackage, } from './meeting-automation.js';
+export const MEETING_AUTOMATION_RUNTIME_VERSION = 'brainbase.meeting-automation-runtime.v1';
+export class MeetingAutomationRuntimeError extends Error {
+    code;
+    details;
+    constructor(code, message, details = {}) {
+        super(message);
+        this.name = 'MeetingAutomationRuntimeError';
+        this.code = code;
+        this.details = details;
+    }
+}
+function stable(value) {
+    if (Array.isArray(value))
+        return value.map(stable);
+    if (!value || typeof value !== 'object')
+        return value;
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stable(value[key])]));
+}
+function digest(value) {
+    return createHash('sha256').update(JSON.stringify(stable(value))).digest('hex');
+}
+function requireScope(value, field) {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new MeetingAutomationRuntimeError('invalid_scope', `${field} is required`, { field });
+    }
+    return value.trim();
+}
+function retryable(error, ports) {
+    return ports.is_retryable?.(error) ?? Boolean(error?.retryable);
+}
+function normalizeReviewPackage(input) {
+    const reviewPackage = input.review_package;
+    assertMeetingCandidatesInput(reviewPackage);
+    const caseScope = input.case_scope ?? (typeof reviewPackage.case_scope === 'string' ? reviewPackage.case_scope : null);
+    const evidenceRefs = Array.isArray(input.evidence_refs) ? [...input.evidence_refs] : [];
+    const normalizedTaskCandidates = normalizeTaskCandidates(reviewPackage.task_candidates, {
+        caseScope,
+        evidenceRefs,
+    });
+    const normalizedDecisionCandidates = normalizeDecisionCandidates(reviewPackage.decision_candidates, {
+        caseScope,
+        evidenceRefs,
+    });
+    return {
+        ...reviewPackage,
+        task_candidates: normalizedTaskCandidates,
+        decision_candidates: normalizedDecisionCandidates,
+        follow_up_draft: normalizeFollowUpDraft(reviewPackage.follow_up_draft),
+    };
+}
+async function saveWithRetry(record, ports) {
+    const maxAttempts = Math.max(1, Math.min(5, ports.max_attempts ?? 2));
+    let attempts = 0;
+    let lastError;
+    while (attempts < maxAttempts) {
+        attempts += 1;
+        try {
+            const saved = await ports.ledger.save(record);
+            return { record: saved ?? record, attempts };
+        }
+        catch (error) {
+            lastError = error;
+            if (!retryable(error, ports) || attempts >= maxAttempts)
+                throw error;
+        }
+    }
+    throw new MeetingAutomationRuntimeError('persist_failed', 'meeting automation record could not be persisted', {
+        attempts,
+        cause: lastError instanceof Error ? lastError.message : String(lastError),
+    });
+}
+/**
+ * Provider-independent orchestration for meeting review package ingestion.
+ * The host owns workflow, Graph, identity and durable ledger ports; this core
+ * owns validation, normalization, replay keys, retry and persisted readback.
+ */
+export async function runMeetingAutomationRuntime(input, ports) {
+    const orgId = requireScope(input.org_id, 'org_id');
+    const projectId = requireScope(input.project_id, 'project_id');
+    if (!ports?.ledger || typeof ports.ledger.save !== 'function') {
+        throw new MeetingAutomationRuntimeError('invalid_ports', 'a meeting review ledger save port is required');
+    }
+    if (typeof ports.ledger.claimOrReplay !== 'function' || typeof ports.ledger.readback !== 'function') {
+        throw new MeetingAutomationRuntimeError('invalid_ports', 'meeting review ledger claimOrReplay and durable readback ports are required');
+    }
+    const normalizedPackage = normalizeReviewPackage(input);
+    // Keep the incoming contract separate from the persisted post-owner
+    // fingerprint. Owner resolution may add fields, while an explicit
+    // idempotency key must still reject a replay carrying a different input
+    // package. Ingestion time is intentionally excluded.
+    const inputFingerprint = digest({ org_id: orgId, project_id: projectId, review_package: normalizedPackage });
+    // An explicit key can be replayed before owner/Graph work.  This keeps a
+    // duplicate delivery from doing any host-side resolution while the atomic
+    // claim below remains the authority for a concurrent miss.
+    const explicitIdempotencyKey = typeof input.idempotency_key === 'string' && input.idempotency_key.trim()
+        ? input.idempotency_key.trim()
+        : null;
+    const earlyReplay = explicitIdempotencyKey && ports.ledger.findByIdempotencyKey
+        ? await ports.ledger.findByIdempotencyKey(explicitIdempotencyKey, { org_id: orgId, project_id: projectId })
+        : null;
+    if (earlyReplay) {
+        const readback = await ports.ledger.readback(earlyReplay.record_id, { org_id: orgId, project_id: projectId });
+        if (!readback) {
+            throw new MeetingAutomationRuntimeError('readback_mismatch', 'meeting automation ledger replay was not durable', {
+                record_id: earlyReplay.record_id,
+            });
+        }
+        if (readback.input_fingerprint && readback.input_fingerprint !== inputFingerprint) {
+            throw new MeetingAutomationRuntimeError('idempotency_conflict', 'meeting automation replay input differs from the claimed key', {
+                idempotency_key: explicitIdempotencyKey,
+            });
+        }
+        const replayPackage = readback.review_package;
+        const verified = verifyMeetingReviewPackage({
+            repository: input.loop_intent_repository,
+            reviewPackage: replayPackage,
+            orgId,
+            projectId,
+        });
+        if (readback.idempotency_key !== explicitIdempotencyKey) {
+            throw new MeetingAutomationRuntimeError('idempotency_conflict', 'idempotency key replay returned a different key', {
+                idempotency_key: explicitIdempotencyKey,
+            });
+        }
+        const knowledge = await runKnowledgeBridge({
+            ports,
+            orgId,
+            projectId,
+            reviewPackage: replayPackage,
+            record: readback,
+            idempotencyKey: explicitIdempotencyKey,
+        });
+        return {
+            status: 'replayed',
+            idempotent: true,
+            attempts: 0,
+            record: readback,
+            readback,
+            verified,
+            workflow: null,
+            knowledge,
+        };
+    }
+    const ownerResolved = ports.resolveTaskOwners
+        ? await ports.resolveTaskOwners({ task_candidates: normalizedPackage.task_candidates }, { org_id: orgId, project_id: projectId })
+        : null;
+    const reviewPackageWithOwners = ownerResolved?.task_candidates
+        ? { ...normalizedPackage, task_candidates: ownerResolved.task_candidates }
+        : normalizedPackage;
+    // Owner resolution is an injected host port.  Re-run the candidate input
+    // contract after it returns so a resolver cannot replace the normalized
+    // package with an invalid candidate shape before the review verification.
+    assertMeetingCandidatesInput(reviewPackageWithOwners);
+    const verified = verifyMeetingReviewPackage({
+        repository: input.loop_intent_repository,
+        // Owner resolution changes the contract being persisted.  Verify the
+        // resolved package itself so an injected/host resolver cannot bypass the
+        // review-package contract.
+        reviewPackage: reviewPackageWithOwners,
+        orgId,
+        projectId,
+    });
+    const fingerprint = digest({ org_id: orgId, project_id: projectId, review_package: reviewPackageWithOwners });
+    const idempotencyKey = explicitIdempotencyKey
+        ? explicitIdempotencyKey
+        : `meeting-review:${orgId}:${projectId}:${fingerprint}`;
+    const scope = { org_id: orgId, project_id: projectId };
+    const claim = await ports.ledger.claimOrReplay({
+        idempotency_key: idempotencyKey,
+        fingerprint,
+        scope,
+        execute: async () => {
+            const workflow = await ports.prepareWorkflow?.({
+                org_id: orgId,
+                project_id: projectId,
+                review_package: reviewPackageWithOwners,
+                idempotency_key: idempotencyKey,
+            }) ?? null;
+            const now = (ports.now ?? (() => new Date()))().toISOString();
+            const record = {
+                record_id: `mrev_${fingerprint.slice(0, 32)}`,
+                idempotency_key: idempotencyKey,
+                input_fingerprint: inputFingerprint,
+                fingerprint,
+                org_id: orgId,
+                project_id: projectId,
+                state: 'waiting_human',
+                review_package: reviewPackageWithOwners,
+                verified_loop_intents: verified.loopIntents.map(({ loop_intent }) => String(loop_intent.id ?? '')),
+                created_at: now,
+                actor_id: input.actor_id ?? null,
+            };
+            const persisted = await saveWithRetry(record, ports);
+            return {
+                record: persisted.record,
+                attempts: persisted.attempts,
+                workflow,
+                knowledge: null,
+            };
+        },
+    });
+    const execution = claim.execution;
+    if (execution.record.input_fingerprint && execution.record.input_fingerprint !== inputFingerprint) {
+        throw new MeetingAutomationRuntimeError('idempotency_conflict', 'meeting automation claim returned a different input package', {
+            idempotency_key: idempotencyKey,
+        });
+    }
+    const readback = await ports.ledger.readback(execution.record.record_id, scope);
+    if (!readback || readback.fingerprint !== execution.record.fingerprint) {
+        throw new MeetingAutomationRuntimeError('readback_mismatch', 'meeting automation ledger readback did not match the persisted record', {
+            record_id: execution.record.record_id,
+        });
+    }
+    const knowledge = await runKnowledgeBridge({
+        ports,
+        orgId,
+        projectId,
+        reviewPackage: execution.record.review_package,
+        record: readback,
+        idempotencyKey,
+    });
+    return {
+        status: claim.status,
+        idempotent: claim.status === 'replayed',
+        attempts: claim.status === 'replayed' ? 0 : execution.attempts,
+        record: execution.record,
+        readback,
+        verified,
+        workflow: claim.status === 'replayed' ? null : execution.workflow,
+        knowledge,
+    };
+}
+async function runKnowledgeBridge({ ports, orgId, projectId, reviewPackage, record, idempotencyKey, }) {
+    if (!ports.bridgeKnowledge)
+        return null;
+    if (!ports.runOnce) {
+        throw new MeetingAutomationRuntimeError('invalid_ports', 'meeting automation knowledge bridge requires a durable post-commit runOnce port');
+    }
+    const knowledge = await ports.runOnce(`meeting-review:${idempotencyKey}:knowledge-bridge`, () => ports.bridgeKnowledge?.({
+        org_id: orgId,
+        project_id: projectId,
+        review_package: reviewPackage,
+        record,
+        idempotency_key: idempotencyKey,
+    }) ?? null);
+    return (knowledge ?? null);
+}

package/dist/meeting-automation.d.ts

@@ -0,0 +1,155 @@
+declare const EXTERNAL_RUNTIME_CANDIDATE_SOURCE = "external_meeting_runtime";
+type RecordValue = Record<string, unknown>;
+export interface MeetingCandidate {
+    id: string;
+    title: string;
+    status: 'candidate';
+    source: typeof EXTERNAL_RUNTIME_CANDIDATE_SOURCE;
+    case_scope: string | null;
+    owner_hint?: string | null;
+    due_hint?: string | null;
+    decision_type?: string;
+    source_excerpt?: string | null;
+    evidence_refs: unknown[];
+}
+export interface FollowUpDraft {
+    status: 'draft_only';
+    external_send_required_approval: true;
+    body: string;
+}
+export interface MeetingLoopIntent {
+    id?: string;
+    org_id: string;
+    project_id: string;
+    [key: string]: unknown;
+}
+export interface MeetingLoopIntentRepository {
+    getLoopIntent(loopIntentId: string): MeetingLoopIntent | null | undefined;
+}
+export interface MeetingReviewPackage {
+    meeting_note_summary: unknown;
+    task_candidates: unknown;
+    decision_candidates: unknown;
+    follow_up_draft: unknown;
+    promotion_candidates: unknown;
+    loop_intent_ids: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface VerifyMeetingReviewPackageInput {
+    repository: MeetingLoopIntentRepository;
+    reviewPackage: MeetingReviewPackage;
+    orgId: string;
+    projectId: string;
+}
+export interface MeetingReviewLoopIntentEntry {
+    key: string;
+    loop_intent: MeetingLoopIntent;
+}
+export interface VerifiedMeetingReviewPackage {
+    loopIntents: MeetingReviewLoopIntentEntry[];
+    loopIntentByKey: Map<string, MeetingLoopIntent>;
+}
+export declare class MeetingAutomationContractError extends Error {
+    readonly code = "validation_error";
+    readonly statusCode = 400;
+    readonly status = 400;
+    readonly timestamp: string;
+    readonly details: RecordValue;
+    constructor(message: string, details?: RecordValue);
+    toJSON(): {
+        error: {
+            code: string;
+            message: string;
+            timestamp: string;
+        };
+    };
+}
+export declare function assertMeetingCandidatesInput(input: unknown): asserts input is RecordValue;
+export declare function normalizeTaskCandidates(rawCandidates: unknown, { caseScope, evidenceRefs }?: {
+    caseScope?: string | null;
+    evidenceRefs?: unknown[];
+}): MeetingCandidate[];
+export declare function normalizeDecisionCandidates(rawCandidates: unknown, { caseScope, evidenceRefs }?: {
+    caseScope?: string | null;
+    evidenceRefs?: unknown[];
+}): MeetingCandidate[];
+export declare function normalizeFollowUpDraft(rawDraft: unknown): FollowUpDraft;
+export declare const MEETING_REVIEW_OUTPUT_DEFINITIONS: readonly [{
+    readonly id: "meeting_note_draft";
+    readonly title: "議事録ドラフト";
+    readonly type: "meeting_note_draft";
+    readonly package_key: "meeting_note_summary";
+    readonly loop_intent_key: "transcript_to_meeting_note";
+    readonly write_back_target: "meeting_note_draft";
+}, {
+    readonly id: "task_candidates";
+    readonly title: "Task候補";
+    readonly type: "task_candidates";
+    readonly package_key: "task_candidates";
+    readonly loop_intent_key: "meeting_note_to_tasks";
+    readonly write_back_target: "task_store";
+}, {
+    readonly id: "decision_candidates";
+    readonly title: "Decision候補";
+    readonly type: "decision_candidates";
+    readonly package_key: "decision_candidates";
+    readonly loop_intent_key: "meeting_note_to_decisions";
+    readonly write_back_target: "graph_ssot_decision";
+}, {
+    readonly id: "follow_up_draft";
+    readonly title: "フォローアップ文面ドラフト";
+    readonly type: "message_draft";
+    readonly package_key: "follow_up_draft";
+    readonly loop_intent_key: "post_meeting_follow_up_message";
+    readonly write_back_target: "external_message_draft";
+}, {
+    readonly id: "promotion_candidates";
+    readonly title: "Graph / Learning昇格候補";
+    readonly type: "promotion_candidates";
+    readonly package_key: "promotion_candidates";
+    readonly loop_intent_key: "meeting_note_to_decisions";
+    readonly write_back_target: "candidate_store";
+}];
+export declare const MEETING_REVIEW_HUMAN_STEP_DEFINITIONS: readonly [{
+    readonly id: "approve_meeting_note_publish";
+    readonly step_type: "approval";
+    readonly prompt: "議事録ドラフトの公開可否を確認してください";
+    readonly reason: "required_before_publish";
+    readonly protects: readonly ["meeting_note_publish"];
+    readonly write_back_target: "meeting_note_draft";
+    readonly loop_intent_key: "transcript_to_meeting_note";
+}, {
+    readonly id: "approve_task_candidates";
+    readonly step_type: "approval";
+    readonly prompt: "Task候補を作成してよいか確認してください";
+    readonly reason: "required_before_task_create";
+    readonly protects: readonly ["task_create"];
+    readonly write_back_target: "task_store";
+    readonly loop_intent_key: "meeting_note_to_tasks";
+}, {
+    readonly id: "approve_decision_candidates";
+    readonly step_type: "approval";
+    readonly prompt: "Decision候補をGraph SSOTへ昇格してよいか確認してください";
+    readonly reason: "required_before_graph_promotion";
+    readonly protects: readonly ["decision_promotion", "graph_promotion"];
+    readonly write_back_target: "graph_ssot_decision";
+    readonly loop_intent_key: "meeting_note_to_decisions";
+}, {
+    readonly id: "approve_follow_up_draft";
+    readonly step_type: "approval";
+    readonly prompt: "フォローアップ文面を外部送信してよいか確認してください";
+    readonly reason: "required_before_external_send";
+    readonly protects: readonly ["external_send"];
+    readonly write_back_target: "external_message_draft";
+    readonly loop_intent_key: "post_meeting_follow_up_message";
+}, {
+    readonly id: "approve_promotion_candidates";
+    readonly step_type: "approval";
+    readonly prompt: "Graph / Learning昇格候補を次の審査へ回してよいか確認してください";
+    readonly reason: "required_before_candidate_promotion";
+    readonly protects: readonly ["graph_candidate_promotion", "learning_candidate_promotion"];
+    readonly write_back_target: "candidate_store";
+    readonly loop_intent_key: "meeting_note_to_decisions";
+}];
+export declare function verifyMeetingReviewPackage({ repository, reviewPackage, orgId, projectId }: VerifyMeetingReviewPackageInput): VerifiedMeetingReviewPackage;
+export {};