@unson/brainbase-mcp 0.7.0 → 0.8.0

package/contracts/judgment-value-proof/schema.json

@@ -53,6 +53,35 @@
             { "type": "boolean" },
             { "const": "unconfirmed" }
           ]
+        },
+        "judgment_kind": {
+          "oneOf": [
+            { "type": "null" },
+            {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["key", "label"],
+              "properties": {
+                "key": { "type": "string", "pattern": "^[a-z0-9_]{1,64}$" },
+                "label": { "type": "string", "minLength": 1 }
+              }
+            }
+          ]
+        },
+        "inheritance": {
+          "oneOf": [
+            { "type": "null" },
+            {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["sources", "same_conditions", "rechecked_conditions"],
+              "properties": {
+                "sources": { "type": "array", "items": { "$ref": "#/$defs/inheritance_source" } },
+                "same_conditions": { "type": "array", "items": { "type": "string", "minLength": 1 } },
+                "rechecked_conditions": { "type": "array", "items": { "type": "string", "minLength": 1 } }
+              }
+            }
+          ]
         }
       }
     },
@@ -123,7 +152,20 @@
       "required": ["entity_id", "application"],
       "properties": {
         "entity_id": { "type": "string", "minLength": 1 },
-        "application": { "type": "string", "minLength": 1 }
+        "application": { "type": "string", "minLength": 1 },
+        "layer": { "enum": ["philosophy", "objective", "world_model", "method", "constraint", "other"] },
+        "version": { "type": ["string", "null"] }
+      }
+    },
+    "inheritance_source": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["kind", "ref", "version", "label"],
+      "properties": {
+        "kind": { "enum": ["judgment", "method", "decision", "other"] },
+        "ref": { "type": "string", "minLength": 1 },
+        "version": { "type": ["string", "null"] },
+        "label": { "type": "string", "minLength": 1 }
       }
     },
     "artifact_ref": {

package/dist/canonical-task-service.js

@@ -55,13 +55,16 @@ function failValidation(fieldErrors) {
     throw new CanonicalTaskError('validation_failed', 'Canonical Task request is invalid', 422, { fieldErrors }, { fieldErrors });
 }
 function normalizeString(value, field, options = {}) {
-    const normalized = value == null ? '' : String(value).normalize('NFKC').trim();
+    const text = value == null ? '' : String(value).normalize('NFKC');
+    // Multi-line fields keep line breaks and tabs; CRLF/CR are stored as LF.
+    const normalized = (options.multiline ? text.replace(/\r\n?/gu, '\n') : text).trim();
     if (!normalized) {
         if (options.required)
             fail('validation_error', `${field} is required`, 400, { field });
         return null;
     }
-    if (/[\u0000-\u001f\u007f]/u.test(normalized)) {
+    const controlCharacters = options.multiline ? /[\u0000-\u0008\u000b-\u001f\u007f]/u : /[\u0000-\u001f\u007f]/u;
+    if (controlCharacters.test(normalized)) {
         fail('validation_error', `${field} contains control characters`, 400, { field });
     }
     if (options.max && normalized.length > options.max) {
@@ -163,6 +166,14 @@ function projectTaskResult(result) {
     }
     return result;
 }
+// Repositories report warnings as `{ code, message }` objects or legacy strings.
+// The page contract is string[], so keep the code rather than "[object Object]".
+function warningCode(warning) {
+    if (typeof warning === 'string')
+        return warning;
+    const code = warning?.code;
+    return typeof code === 'string' && code ? code : JSON.stringify(warning);
+}
 function normalizePage(page, normalize) {
     const items = Array.isArray(page.items) ? page.items.map(normalize) : [];
     // An explicit null means that the backend did not request or cannot provide
@@ -185,7 +196,7 @@ function normalizePage(page, normalize) {
         count_status: countStatus,
         next_cursor: nextCursor,
         read_status: readStatus,
-        warnings: items.flatMap((task) => Array.isArray(task.normalization_warnings) ? task.normalization_warnings.map(String) : []),
+        warnings: items.flatMap((task) => Array.isArray(task.normalization_warnings) ? task.normalization_warnings.map(warningCode) : []),
     };
 }
 export class CanonicalTaskService {
@@ -598,7 +609,7 @@ export class CanonicalTaskService {
             fail('validation_error', 'priority is invalid', 400, { field: 'priority' });
         return {
             title,
-            description: normalizeString(input.description, 'description', { max: 10000 }),
+            description: normalizeString(input.description, 'description', { max: 10000, multiline: true }),
             priority,
             assignee_person_id: normalizeString(input.assignee_person_id, 'assignee_person_id', { max: 200 }),
             due_at: normalizeIsoDate(input.due_at, 'due_at'),
@@ -618,7 +629,7 @@ export class CanonicalTaskService {
         if ('title' in input)
             patch.title = normalizeString(input.title, 'title', { required: true, max: MAX_TITLE_LENGTH });
         if ('description' in input)
-            patch.description = normalizeString(input.description, 'description', { max: 10000 });
+            patch.description = normalizeString(input.description, 'description', { max: 10000, multiline: true });
         if ('priority' in input) {
             const priority = input.priority == null || input.priority === '' ? null : String(input.priority);
             if (priority != null && !isCanonicalTaskPriority(priority))

package/dist/cli.d.ts

@@ -7,6 +7,8 @@ interface CliIo {
     stderr?: {
         write(chunk: string): unknown;
     };
+    /** Stops a long-running command such as web:serve (besides SIGINT/SIGTERM). */
+    signal?: AbortSignal;
 }
 export declare function runCli(argv?: string[], io?: CliIo): Promise<number>;
 export declare function isCliEntrypoint(moduleUrl: string, invokedPath: string | undefined): boolean;

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { createPortableGraph, portableGraphDigest } from './portable-graph.js';
 import { createOrganizationGraphConfig, createOrganizationGraphClient } from './organization-graph.js';
+import { listLocalMemories, memoryListJson, registerSelectedMemories, registrationPreviewJson, renderMemoryList, renderRegistrationPreview, renderRegistrationResult, selectLocalMemories } from './personal-memory-handover.js';
 import { constants, realpathSync } from 'node:fs';
 import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
 import { delimiter, dirname, isAbsolute, join } from 'node:path';
@@ -19,6 +20,8 @@ import { buildProjectRegistrationPlan, parseProjectSource, parseProjectStakehold
 import { renderGuidedFirstRun } from './guided-onboarding.js';
 import { blockedJudgmentOutput, processJudgmentHook } from './judgment-host.js';
 import { applyCanonicalWrites, buildCanonicalEdge } from './canonical-edge-builder.js';
+import { defaultJudgmentJournalRoot } from './judgment-value-proof-review.js';
+import { createLocalWebHost, LOCAL_WEB_DEFAULT_PORT } from './local-web-host.js';
 export async function runCli(argv = process.argv.slice(2), io = process) {
     const parsed = parseArgs(argv);
     try {
@@ -41,6 +44,27 @@ export async function runCli(argv = process.argv.slice(2), io = process) {
                     sourceFilesUnchanged: true, graphId: config.graphId }) + '\n');
                 return 0;
             }
+            case 'graph:bundles': {
+                const config = createOrganizationGraphConfig();
+                if (!config)
+                    throw new Error('graph:bundles requires all BRAINBASE_ORGANIZATION_* settings');
+                const format = first(parsed, 'format') ?? 'text';
+                if (format !== 'text' && format !== 'json')
+                    throw new Error('graph:bundles --format must be text or json');
+                const list = await createOrganizationGraphClient(config).listPortableGraphs();
+                if (format === 'json')
+                    write(io, `${JSON.stringify(list, null, 2)}\n`);
+                else if (list.bundles.length === 0)
+                    write(io, 'No Graph bundles have been uploaded to this organization yet.\n');
+                else
+                    write(io, list.bundles.map((entry) => `${entry.createdAt}  ${entry.projectCode}  ${entry.graphId}  ${entry.digest}\n`).join('')
+                        + (list.truncated ? `Only the newest ${list.bundles.length} bundle(s) are shown.\n` : ''));
+                return 0;
+            }
+            case 'memory:list':
+                return await memoryList(parsed, io);
+            case 'memory:register':
+                return await memoryRegister(parsed, io);
             case 'onboard:init':
                 return await onboardInit(parsed, io);
             case 'onboard:seed':
@@ -86,6 +110,10 @@ export async function runCli(argv = process.argv.slice(2), io = process) {
                 return await judgmentInstall(parsed, io);
             case 'doctor':
                 return await doctor(parsed, io);
+            case 'web:serve':
+            case 'review:serve':
+                // review:serve is kept as an alias of the same local Web host.
+                return await webServe(parsed, io, parsed.command);
             case 'mcp':
                 await import('./index.js');
                 return 0;
@@ -175,6 +203,36 @@ async function readHookStdin(input) {
         text += typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8');
     return text;
 }
+function textOrJsonFormat(parsed, command) {
+    const format = first(parsed, 'format') ?? 'text';
+    if (format !== 'text' && format !== 'json')
+        throw new Error(`${command} --format must be text or json`);
+    return format;
+}
+async function memoryList(parsed, io) {
+    const format = textOrJsonFormat(parsed, 'memory:list');
+    const memories = await listLocalMemories(first(parsed, 'dir'));
+    write(io, format === 'json' ? `${JSON.stringify(memoryListJson(memories), null, 2)}\n` : renderMemoryList(memories));
+    return 0;
+}
+async function memoryRegister(parsed, io) {
+    const format = textOrJsonFormat(parsed, 'memory:register');
+    const ids = parsed.values.get('id') ?? [];
+    if (ids.length === 0)
+        throw new Error('memory:register requires at least one --id <id> (see brainbase memory:list)');
+    const dataDir = first(parsed, 'dir');
+    if (!parsed.flags.has('write')) {
+        const selected = selectLocalMemories(await listLocalMemories(dataDir), ids);
+        write(io, format === 'json' ? `${JSON.stringify(registrationPreviewJson(selected), null, 2)}\n` : renderRegistrationPreview(selected));
+        return 0;
+    }
+    const config = createOrganizationGraphConfig();
+    if (!config)
+        throw new Error('memory:register --write requires all BRAINBASE_ORGANIZATION_* settings; nothing was sent');
+    const result = await registerSelectedMemories({ dataDir, ids, organization: { url: config.url, token: config.token } });
+    write(io, format === 'json' ? `${JSON.stringify({ status: 'registered', ...result }, null, 2)}\n` : renderRegistrationResult(result));
+    return 0;
+}
 async function onboardInit(parsed, io) {
     const dataDir = resolveDataDir(first(parsed, 'dir'));
     await initializePersonalOs(dataDir);
@@ -976,6 +1034,50 @@ async function doctor(parsed, io) {
 function graphDiagnosisExitCode(status) {
     return status === 'invalid' || status === 'unavailable' || status === 'migration_required' ? 1 : 0;
 }
+async function webServe(parsed, io, command) {
+    const dataDir = resolveDataDir(first(parsed, 'dir'));
+    const journalRoot = first(parsed, 'journal')
+        ?? process.env.BRAINBASE_JUDGMENT_JOURNAL_DIR
+        ?? defaultJudgmentJournalRoot(dataDir);
+    const port = Number(first(parsed, 'port') ?? String(LOCAL_WEB_DEFAULT_PORT));
+    if (!Number.isInteger(port) || port < 0 || port > 65535) {
+        throw new Error(`${command} requires --port to be an integer between 0 and 65535`);
+    }
+    const { server } = createLocalWebHost({ dataDir, journalRoot });
+    await new Promise((resolveListen, rejectListen) => {
+        server.once('error', rejectListen);
+        server.listen(port, '127.0.0.1', () => resolveListen());
+    });
+    const address = server.address();
+    const actualPort = typeof address === 'object' && address ? address.port : port;
+    const origin = `http://127.0.0.1:${actualPort}`;
+    write(io, [
+        `Brainbase: ${origin}/`,
+        `- 今日（判断の見返し）: ${origin}/#today`,
+        `- 目的と現状: ${origin}/#objectives`,
+        `- プロジェクトと関係者: ${origin}/#projects`,
+        `- 情報と関係: ${origin}/#graph`,
+        `データ: ${dataDir}`,
+        `判断journal: ${journalRoot}`,
+        '終了: Ctrl+C',
+        ''
+    ].join('\n'));
+    await new Promise((resolveClose) => {
+        const stop = () => {
+            process.off('SIGINT', stop);
+            process.off('SIGTERM', stop);
+            io.signal?.removeEventListener('abort', stop);
+            server.close(() => resolveClose());
+        };
+        process.once('SIGINT', stop);
+        process.once('SIGTERM', stop);
+        if (io.signal?.aborted)
+            stop();
+        else
+            io.signal?.addEventListener('abort', stop, { once: true });
+    });
+    return 0;
+}
 function parseArgs(argv) {
     const [firstToken, ...remaining] = argv;
     const command = firstToken?.startsWith('--') ? undefined : firstToken;
@@ -1104,10 +1206,15 @@ function usage() {
   brainbase ontology:show
   brainbase ontology:audit [--dir path] [--ontology-version 0.0.0|1.0.0|2.0.0]
   brainbase graph:upgrade [--dir path]
+  brainbase graph:bundles [--format text|json]
+  brainbase memory:list [--dir path] [--format text|json]
+  brainbase memory:register --id id [--id id...] [--dir path] [--write] [--format text|json]
   brainbase ontology:migrate [--dir path] [--write --expected-input-digest digest]
   brainbase judgment:install --target codex [--autonomy-mode off|canary|on] [--autonomy-project code] [--dry-run] [--output path]
   brainbase judgment:hook [--autonomy-mode off|canary|on] [--autonomy-project code]
   brainbase doctor [--dir path] [--judgment-hooks path]
+  brainbase web:serve [--dir path] [--journal path] [--port n]
+  brainbase review:serve [--dir path] [--journal path] [--port n]  （web:serveの別名）
 `;
 }
 function shellArg(value) {

package/dist/company-os-objectives.d.ts

@@ -13,6 +13,11 @@ export interface ObjectiveReadiness {
     /** Definition and referenced Variable issues; observations are not inferred. */
     issues: readonly ObjectiveReadinessIssue[];
 }
+/** The canonical read surface needed to check an Objective and its criteria. */
+export interface ObjectiveReadinessReader {
+    read(reference: FoundationRevision, context: FoundationStoreContext): Promise<FoundationCatalogRecord | null>;
+    readLatest?(type: 'objective' | 'variable', id: string, context: FoundationStoreContext): Promise<FoundationCatalogRecord | null>;
+}
 export type StoryObjectiveLinkKind = 'contribution' | 'execution_dependency' | 'time_condition';
 export interface StoryObjectiveLinkInput {
     storyId: string;
@@ -49,4 +54,10 @@ export declare class CompanyOsObjectives {
     linkObjectiveStory(input: StoryObjectiveLinkInput, context: FoundationStoreContext): Promise<void>;
     private readTyped;
 }
+/**
+ * Check an Objective and every Variable revision named by its criteria.
+ * Both the Objective service and judgment snapshot providers call this
+ * function so readiness cannot vary by caller.
+ */
+export declare function checkObjectiveReadiness(reader: ObjectiveReadinessReader, id: string, context: FoundationStoreContext, revision?: string): Promise<ObjectiveReadiness>;
 export declare function createCompanyOsObjectives(store: FoundationRevisionStore): CompanyOsObjectives;

package/dist/company-os-objectives.js

@@ -27,53 +27,7 @@ export class CompanyOsObjectives {
         }, context);
     }
     async checkObjectiveReadiness(id, context, revision) {
-        const record = await this.readObjective(id, context, revision);
-        if (!record) {
-            return {
-                ready: false,
-                issues: [{ code: 'NOT_FOUND', path: 'id', message: `Objective ${id} was not found.` }]
-            };
-        }
-        const objective = record.definition;
-        const issues = validationIssues(objective, 'judgment');
-        const criteria = Array.isArray(objective.criteria) ? objective.criteria : [];
-        for (const [index, criterion] of criteria.entries()) {
-            if (!criterion || typeof criterion !== 'object' || !criterion.variableRef)
-                continue;
-            if (!isVariableRevisionReference(criterion.variableRef)) {
-                issues.push({
-                    code: 'INVALID_VARIABLE_REFERENCE',
-                    path: `criteria[${index}].variableRef`,
-                    message: 'Criterion must reference a Variable with a positive revision.'
-                });
-                continue;
-            }
-            const variable = await this.store.read(criterion.variableRef, context);
-            if (!variable) {
-                issues.push({
-                    code: 'MISSING_VARIABLE_REVISION',
-                    path: `criteria[${index}].variableRef`,
-                    message: `Variable ${criterion.variableRef.id}@${criterion.variableRef.revision} was not found.`
-                });
-                continue;
-            }
-            if (variable.definition.type !== 'variable') {
-                issues.push({
-                    code: 'INVALID_VARIABLE_REFERENCE',
-                    path: `criteria[${index}].variableRef`,
-                    message: `Criterion ${criterion.variableRef.id}@${criterion.variableRef.revision} is not a Variable.`
-                });
-                continue;
-            }
-            for (const issue of validationIssues(variable.definition, 'judgment')) {
-                issues.push({
-                    ...issue,
-                    path: `criteria[${index}].variableRef.${issue.path}`
-                });
-            }
-            issues.push(...criterionCompatibilityIssues(criterion, variable.definition, index));
-        }
-        return { ready: issues.length === 0, issues };
+        return checkObjectiveReadiness(this.store, id, context, revision);
     }
     createVariable(definition, context) {
         assertType(definition, 'variable');
@@ -130,6 +84,69 @@ export class CompanyOsObjectives {
         return this.store.readLatest(type, id, context);
     }
 }
+/**
+ * Check an Objective and every Variable revision named by its criteria.
+ * Both the Objective service and judgment snapshot providers call this
+ * function so readiness cannot vary by caller.
+ */
+export async function checkObjectiveReadiness(reader, id, context, revision) {
+    const record = revision === undefined
+        ? reader.readLatest === undefined ? null : await reader.readLatest('objective', id, context)
+        : await reader.read({ id, type: 'objective', revision }, context);
+    if (!record) {
+        return {
+            ready: false,
+            issues: [{ code: 'NOT_FOUND', path: 'id', message: `Objective ${id} was not found.` }]
+        };
+    }
+    if (record.definition.type !== 'objective') {
+        return {
+            ready: false,
+            issues: [{ code: 'INVALID_OBJECTIVE_REFERENCE', path: 'type', message: `Foundation ${id} is not an Objective.` }]
+        };
+    }
+    const objective = record.definition;
+    const issues = validationIssues(objective, 'judgment');
+    const criteria = Array.isArray(objective.criteria) ? objective.criteria : [];
+    for (const [index, criterion] of criteria.entries()) {
+        if (!criterion || typeof criterion !== 'object' || !criterion.variableRef)
+            continue;
+        if (!isVariableRevisionReference(criterion.variableRef)) {
+            issues.push({
+                code: 'INVALID_VARIABLE_REFERENCE',
+                path: `criteria[${index}].variableRef`,
+                message: 'Criterion must reference a Variable with a positive revision.'
+            });
+            continue;
+        }
+        const variable = await reader.read(criterion.variableRef, context);
+        if (!variable) {
+            issues.push({
+                code: 'MISSING_VARIABLE_REVISION',
+                path: `criteria[${index}].variableRef`,
+                message: `Variable ${criterion.variableRef.id}@${criterion.variableRef.revision} was not found.`
+            });
+            continue;
+        }
+        if (variable.definition.type !== 'variable') {
+            issues.push({
+                code: 'INVALID_VARIABLE_REFERENCE',
+                path: `criteria[${index}].variableRef`,
+                message: `Criterion ${criterion.variableRef.id}@${criterion.variableRef.revision} is not a Variable.`
+            });
+            continue;
+        }
+        for (const issue of validationIssues(variable.definition, 'judgment')) {
+            issues.push({
+                ...issue,
+                path: `criteria[${index}].variableRef.${issue.path}`
+            });
+        }
+        issues.push(...criterionCompatibilityIssues(criterion, variable.definition, index));
+        issues.push(...criterionPeriodIssues(objective, variable.definition, index));
+    }
+    return { ready: issues.length === 0, issues };
+}
 export function createCompanyOsObjectives(store) {
     return new CompanyOsObjectives(store);
 }
@@ -195,3 +212,23 @@ function criterionCompatibilityIssues(criterion, variable, index) {
     }
     return [];
 }
+function criterionPeriodIssues(objective, variable, index) {
+    const objectiveFrom = Date.parse(objective.evaluationPeriod?.from ?? '');
+    const objectiveUntil = Date.parse(objective.evaluationPeriod?.until ?? '');
+    const variableFrom = Date.parse(variable.scope?.validFrom ?? '');
+    const variableUntil = variable.scope?.validUntil === undefined
+        ? Number.POSITIVE_INFINITY
+        : Date.parse(variable.scope.validUntil);
+    if (!Number.isFinite(objectiveFrom) || !Number.isFinite(objectiveUntil)
+        || !Number.isFinite(variableFrom)
+        || (variable.scope?.validUntil !== undefined && !Number.isFinite(variableUntil))) {
+        return [];
+    }
+    if (variableFrom <= objectiveFrom && variableUntil >= objectiveUntil)
+        return [];
+    return [{
+            code: 'CRITERION_PERIOD_MISMATCH',
+            path: `criteria[${index}].variableRef`,
+            message: `Variable ${variable.id}@${variable.revision} does not cover the Objective evaluation period.`
+        }];
+}

package/dist/foundation-authenticated-tools.d.ts

@@ -0,0 +1,56 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+export type FoundationAuthenticatedProjectContext = {
+    token: string;
+    scope: string[];
+};
+export type FoundationAuthenticatedToolResult = {
+    status: 'ok' | 'error' | 'unavailable';
+    scope: {
+        project_codes: string[];
+    };
+    data?: unknown;
+    error?: {
+        code: string;
+        message: string;
+        http_status?: number;
+        details?: unknown;
+    };
+};
+export type FoundationAuthenticatedRequest = {
+    path: string;
+    method: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+};
+export type FoundationAuthenticatedJsonResponse = {
+    ok: true;
+    response: Response;
+    payload: unknown;
+    payloadParsed: boolean;
+} | {
+    ok: false;
+    result: FoundationAuthenticatedToolResult;
+};
+/**
+ * Narrow host port for authentication and authenticated Graph requests.
+ * The OSS adapter owns request validation, CSRF/session binding, and response
+ * validation; a connected Host supplies its canonical auth implementation.
+ */
+export type FoundationAuthenticatedToolPort = {
+    authenticateProject(args: Record<string, unknown>, options?: {
+        requireProject?: boolean;
+    }): Promise<FoundationAuthenticatedProjectContext | FoundationAuthenticatedToolResult>;
+    fetchAuthenticatedJson(context: FoundationAuthenticatedProjectContext, request: FoundationAuthenticatedRequest): Promise<FoundationAuthenticatedJsonResponse>;
+    toolError(status: 'error' | 'unavailable', code: string, message: string, scope: string[], httpStatus?: number, details?: unknown): FoundationAuthenticatedToolResult;
+};
+export type FoundationAuthenticatedToolDependencies = {
+    apiUrl: string;
+    fetch?: typeof globalThis.fetch;
+    auth: FoundationAuthenticatedToolPort;
+};
+type FoundationPublicToolName = 'foundation_describe' | 'foundation_read' | 'foundation_validate_reference' | 'foundation_validate_problem';
+export type FoundationPublicToolDependencies = FoundationAuthenticatedToolDependencies;
+export declare const foundationPublicTools: Tool[];
+export declare function isFoundationPublicToolName(name: string): name is FoundationPublicToolName;
+export declare function handleFoundationPublicToolCall(name: string, args: Record<string, unknown>, dependencies: FoundationPublicToolDependencies): Promise<FoundationAuthenticatedToolResult | null>;
+export {};