@unson/brainbase-mcp 0.41.9 → 0.41.11

package/dist/canonical-task-service.d.ts

@@ -31,6 +31,8 @@ export interface CanonicalTaskRecord extends JsonRecord {
     assignee_display_name?: string | null;
     due_at?: string | null;
     waiting_on?: string | null;
+    /** The Graph person a waiting task waits on; null when it waits on a condition or nobody in particular. */
+    waiting_on_person_id?: string | null;
     review_at?: string | null;
     completed_at?: string | null;
     source_refs?: unknown[];
@@ -50,6 +52,7 @@ export interface CanonicalTaskCreateInput extends JsonRecord {
     assignee_person_id?: string | null;
     due_at?: string | null;
     waiting_on?: string | null;
+    waiting_on_person_id?: string | null;
     review_at?: string | null;
     source_refs?: unknown[];
     project_codes?: unknown;
@@ -63,6 +66,7 @@ export interface CanonicalTaskUpdateInput extends JsonRecord {
     assignee_person_id?: string | null;
     due_at?: string | null;
     waiting_on?: string | null;
+    waiting_on_person_id?: string | null;
     review_at?: string | null;
     source_refs?: unknown[];
     source_refs_append?: unknown[];
@@ -231,12 +235,14 @@ export declare class CanonicalTaskService {
     }, context: CanonicalTaskContext): Promise<CanonicalTaskRecord>;
     transitionTask(taskId: string, status: unknown, expectedVersion: number, context: CanonicalTaskContext, input?: {
         waitingOn?: unknown;
+        waitingOnPersonId?: unknown;
         reviewAt?: unknown;
     }): Promise<CanonicalTaskRecord>;
     transitionTask(taskId: string, input: {
         to_status?: unknown;
         expected_version?: number;
         waiting_on?: unknown;
+        waiting_on_person_id?: unknown;
         review_at?: unknown;
     }, context: CanonicalTaskContext): Promise<CanonicalTaskRecord>;
     deleteTask(taskId: string, expectedVersion: number, context: CanonicalTaskContext): Promise<{

package/dist/canonical-task-service.js

@@ -34,6 +34,7 @@ const CREATE_FIELDS = new Set([
     'assignee_person_id',
     'due_at',
     'waiting_on',
+    'waiting_on_person_id',
     'review_at',
     'source_refs',
     'project_codes',
@@ -48,6 +49,7 @@ const MUTABLE_FIELDS = new Set([
     'assignee_person_id',
     'due_at',
     'waiting_on',
+    'waiting_on_person_id',
     'review_at',
     'source_refs',
     'source_refs_append',
@@ -78,6 +80,10 @@ function normalizeString(value, field, options = {}) {
     }
     return normalized;
 }
+/** A Graph person ID, as for the assignee; empty or null means no person. */
+function normalizeWaitingOnPersonId(value) {
+    return normalizeString(value, 'waiting_on_person_id', { max: 200 });
+}
 /** A purpose label: a single line of at most 30 characters; empty or null clears it. */
 const MAX_PURPOSE_LABEL_LENGTH = 30;
 function normalizePurposeLabel(value) {
@@ -511,7 +517,7 @@ export class CanonicalTaskService {
         const expectedVersion = legacyInput ? legacyInput.expected_version : expectedVersionOrContext;
         const context = legacyInput ? expectedVersionOrContext : maybeContext;
         const input = legacyInput
-            ? { waitingOn: legacyInput.waiting_on, reviewAt: legacyInput.review_at }
+            ? { waitingOn: legacyInput.waiting_on, waitingOnPersonId: legacyInput.waiting_on_person_id, reviewAt: legacyInput.review_at }
             : maybeInput;
         const normalizedContext = await this.normalizeContext(context);
         const expected = this.requireExpectedVersion(expectedVersion);
@@ -523,10 +529,13 @@ export class CanonicalTaskService {
                 failValidation({ waiting_on: ['required_for_waiting'] });
             }
             patch.waiting_on = normalizeString(input.waitingOn, 'waiting_on', { required: true, max: 500 });
+            // The person is optional and always replaced, so waiting on a condition clears an earlier person.
+            patch.waiting_on_person_id = normalizeWaitingOnPersonId(input.waitingOnPersonId);
             patch.review_at = normalizeIsoDate(input.reviewAt, 'review_at');
         }
         else {
             patch.waiting_on = input.waitingOn === undefined ? null : normalizeString(input.waitingOn, 'waiting_on', { max: 500 });
+            patch.waiting_on_person_id = input.waitingOnPersonId === undefined ? null : normalizeWaitingOnPersonId(input.waitingOnPersonId);
             patch.review_at = input.reviewAt === undefined ? null : normalizeIsoDate(input.reviewAt, 'review_at');
         }
         return this.versionedMutation({
@@ -801,6 +810,7 @@ export class CanonicalTaskService {
                 transition: {
                     to_status: input.transitionStatus,
                     ...(input.patch.waiting_on !== undefined ? { waiting_on: input.patch.waiting_on } : {}),
+                    ...(input.patch.waiting_on_person_id !== undefined ? { waiting_on_person_id: input.patch.waiting_on_person_id } : {}),
                     ...(input.patch.review_at !== undefined ? { review_at: input.patch.review_at } : {}),
                 },
             };
@@ -818,6 +828,7 @@ export class CanonicalTaskService {
         if (!isCanonicalTaskPriority(priority))
             fail('validation_error', 'priority is invalid', 400, { field: 'priority' });
         const purposeLabel = normalizePurposeLabel(input.purpose_label);
+        const waitingOnPersonId = normalizeWaitingOnPersonId(input.waiting_on_person_id);
         const completionContract = normalizeCompletionContract(input.completion_contract);
         return {
             ...(completionContract ? { completion_contract: completionContract } : {}),
@@ -832,6 +843,8 @@ export class CanonicalTaskService {
             project_codes: normalizeProjectCodes(input.project_codes) ?? [],
             // Only a label that is there is written, so a store without the column still accepts unlabelled work.
             ...(purposeLabel ? { purpose_label: purposeLabel } : {}),
+            // Likewise only a person that is there is written.
+            ...(waitingOnPersonId ? { waiting_on_person_id: waitingOnPersonId } : {}),
         };
     }
     normalizeUpdateInput(input) {
@@ -866,6 +879,8 @@ export class CanonicalTaskService {
             patch.due_at = normalizeIsoDate(input.due_at, 'due_at');
         if ('waiting_on' in input)
             patch.waiting_on = normalizeString(input.waiting_on, 'waiting_on', { max: 500 });
+        if ('waiting_on_person_id' in input)
+            patch.waiting_on_person_id = normalizeWaitingOnPersonId(input.waiting_on_person_id);
         if ('review_at' in input)
             patch.review_at = normalizeIsoDate(input.review_at, 'review_at');
         if ('source_refs' in input && hasSourceRefsAppend) {
@@ -1052,6 +1067,8 @@ export class CanonicalTaskService {
             response.due_at = null;
         if (response.waiting_on === undefined)
             response.waiting_on = null;
+        if (response.waiting_on_person_id === undefined)
+            response.waiting_on_person_id = null;
         if (response.review_at === undefined)
             response.review_at = null;
         if (response.completed_at === undefined)

package/dist/judgment-history.js

@@ -793,6 +793,79 @@ function groupFor(groups, sessionRef, key) {
     groups.set(groupKey, group);
     return group;
 }
+const FRAME_USE_ROLES = new Set(['constraint', 'criterion', 'prediction']);
+const FRAME_USE_VERDICTS = new Set(['satisfied', 'violated', 'tension']);
+const FRAME_PREDICTION_CHECKS = new Set(['held', 'failed', 'unchecked']);
+/**
+ * The usage value shared by every writer of judgment history references
+ * (docs/specs/judgment-history-frame-basis.md): the role in the chosen option,
+ * then the constraint verdict or the prediction check.
+ */
+function frameUseUsage(use) {
+    const role = text(use.role);
+    if (!role || !FRAME_USE_ROLES.has(role))
+        return null;
+    if (role === 'prediction') {
+        const check = isObject(use.check) ? text(use.check.status) : null;
+        return `prediction:${check && FRAME_PREDICTION_CHECKS.has(check) ? check : 'unchecked'}`;
+    }
+    const verdict = text(use.verdict);
+    if (role === 'constraint')
+        return verdict && FRAME_USE_VERDICTS.has(verdict) ? `constraint:${verdict}` : null;
+    return verdict && FRAME_USE_VERDICTS.has(verdict) ? `criterion:${verdict}` : 'criterion';
+}
+/** Carry how the chosen option used each selected reference; rejected options never leak in. */
+function frameReferencesWithUsage(frame) {
+    const references = frame.selected_references;
+    if (!Array.isArray(references))
+        return references;
+    const chosenLabel = text(frame.chosen_option);
+    const chosen = Array.isArray(frame.alternatives)
+        ? frame.alternatives.find((option) => isObject(option) && chosenLabel !== null && option.label === chosenLabel)
+        : null;
+    const uses = isObject(chosen) && Array.isArray(chosen.uses) ? chosen.uses.filter(isObject) : [];
+    return references.map((reference) => {
+        if (!isObject(reference))
+            return reference;
+        const ref = text(reference.ref);
+        const use = ref ? uses.find((candidate) => text(candidate.ref) === ref) : undefined;
+        const usage = use ? frameUseUsage(use) : null;
+        return usage && reference.usage === undefined ? { ...reference, usage } : reference;
+    });
+}
+/**
+ * Personal KG records the owner's answer applied in this turn. Only resolved
+ * answers count; their content never enters the history record.
+ */
+function personalKnowledgeReferences(events) {
+    const references = [];
+    const seen = new Set();
+    for (const event of events) {
+        if (event.success !== true || text(event.event_kind) !== 'personal_answer')
+            continue;
+        const metadata = isObject(event.safe_metadata) ? event.safe_metadata : null;
+        const answer = metadata && isObject(metadata.personal_answer) ? metadata.personal_answer : null;
+        if (!answer || text(answer.status) !== 'resolved' || !Array.isArray(answer.reference_ids))
+            continue;
+        for (const value of answer.reference_ids) {
+            const ref = safeId(value);
+            if (!ref || seen.has(ref))
+                continue;
+            seen.add(ref);
+            references.push({ ref, kind: 'personal_knowledge', version: null, digest: null, why: null, usage: 'applied', availability: 'unknown' });
+        }
+    }
+    return references;
+}
+function withPersonalKnowledge(judgment, events) {
+    const personal = personalKnowledgeReferences(events);
+    if (personal.length === 0)
+        return judgment;
+    const existing = judgment.selected_references ?? [];
+    const known = new Set(existing.map((reference) => `${reference.kind ?? ''}\u0000${reference.ref}`));
+    const added = personal.filter((reference) => !known.has(`${reference.kind}\u0000${reference.ref}`));
+    return added.length === 0 ? judgment : { ...judgment, selected_references: [...existing, ...added] };
+}
 function sourceBlocks(value) {
     if (!value)
         return [];
@@ -808,7 +881,7 @@ function sourceBlocks(value) {
         const frame = isObject(metadata.judgment_frame) ? metadata.judgment_frame : null;
         if (frame)
             blocks.push({
-                selected_references: frame.selected_references,
+                selected_references: frameReferencesWithUsage(frame),
                 alternatives: Array.isArray(frame.alternatives) ? frame.alternatives.map((option) => isObject(option) ? {
                     label: option.label,
                     evaluation: null,
@@ -1018,7 +1091,7 @@ function normalizeFinalRecord(final, sessionRef, key, configuredEntrypoint, turn
         recorded_at: recordedAt,
         project_code: projectCode,
         turn_ref: `${sessionRef}/${sha256(turnId)}`,
-        judgment: mergeJudgment(judgment, blocks, field(blocks[0] ?? null, 'missing_fields')),
+        judgment: withPersonalKnowledge(mergeJudgment(judgment, blocks, field(blocks[0] ?? null, 'missing_fields')), events),
         execution: mergeExecution({ ...execution, status: finalExecutionStatus }, [...executionBlocks(final), ...events.flatMap((event) => executionBlocks(event)).reverse()], completed)
     };
     return { ...baseRecord, missing_fields: missingFields(baseRecord, firstPresent(blocks, 'missing_fields')) };
@@ -1034,7 +1107,7 @@ function mergeRecordWithFinal(adoptionRecord, final, sessionRef, key, turnInput,
         recorded_at: projected.recorded_at,
         project_code: adoptionRecord.project_code ?? projected.project_code,
         entrypoint: adoptionRecord.entrypoint === 'unknown' ? projected.entrypoint : adoptionRecord.entrypoint,
-        judgment: mergeJudgment(adoptionRecord.judgment, blocks, undefined),
+        judgment: withPersonalKnowledge(mergeJudgment(adoptionRecord.judgment, blocks, undefined), events),
         execution
     };
     return { ...baseRecord, missing_fields: missingFields(baseRecord, firstPresent(blocks, 'missing_fields')) };

package/dist/meeting-minutes-http.js

@@ -44,6 +44,9 @@ function routeFor(pathname, basePath) {
     if (segments.length === 4 && noun === 'minutes' && minutesId && action === 'confirm') {
         return { kind: 'confirm', meetingId, minutesId };
     }
+    if (segments.length === 4 && noun === 'minutes' && minutesId && action === 'withdraw') {
+        return { kind: 'withdraw', meetingId, minutesId };
+    }
     if (segments.length === 5 && noun === 'minutes' && minutesId && action === 'versions' && versionId) {
         return { kind: 'version', meetingId, minutesId, versionId };
     }
@@ -157,6 +160,13 @@ function confirmInput(body, minutesId, key, fingerprint) {
         ...idempotencyFields(key, fingerprint)
     };
 }
+function withdrawInput(body, minutesId, key, fingerprint) {
+    return {
+        minutes_id: minutesId,
+        expected_revision: body.expected_revision,
+        ...idempotencyFields(key, fingerprint)
+    };
+}
 export function createMeetingMinutesHttpHandler(options) {
     if (!options || !options.store || typeof options.resolveContext !== 'function') {
         throw new TypeError('store and resolveContext are required');
@@ -202,6 +212,15 @@ export function createMeetingMinutesHttpHandler(options) {
                     }
                     return { statusCode: 200, body: await options.store.confirm_version(confirmInput(body, document.minutes_id, key, fingerprint), context) };
                 }
+                case 'withdraw': {
+                    if (body === undefined)
+                        throw new MeetingMinutesError('invalid_input', 'Request body is required');
+                    const detail = await options.store.get_meeting(route.meetingId ?? '', context);
+                    const document = detail.minutes.find((candidate) => candidate.minutes_id === route.minutesId);
+                    if (!document)
+                        throw new MeetingMinutesError('not_found', `Minutes document ${route.minutesId} was not found`);
+                    return { statusCode: 200, body: await options.store.withdraw_minutes(withdrawInput(body, document.minutes_id, key, fingerprint), context) };
+                }
                 case 'version':
                     return {
                         statusCode: 200,

package/dist/meeting-minutes.js

@@ -1132,6 +1132,10 @@ export function createMeetingMinutesStore(options) {
         const meeting = findMeeting(snapshot, document.meeting_id);
         await authorized(authorizer, 'write', meeting, context);
         await authorized(authorizer, 'write', document, context);
+        // Only the person who made the document takes it back (story-meeting-minutes-edit-and-withdraw-ui-v1).
+        if (document.created_actor_id !== principal) {
+            throw new MeetingMinutesError('authorization_denied', 'Only the person who made this minutes document can withdraw it');
+        }
         // Withdrawing twice keeps the first record; a retry is not a second withdrawal.
         if (document.withdrawal && !idempotency.token)
             return detailForCaller(snapshot, meeting, context);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.41.9",
+  "version": "0.41.11",
   "description": "Local-first Brainbase judgment OS that lets supported AI agents reuse a user's approved goals, priorities, decisions, and judgment criteria.",
   "type": "module",
   "license": "MIT",
@@ -483,5 +483,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "76bf4ebe18b116379d4687272baecdc4a74dbb35"
+  "gitHead": "3849d107c129672e91d6c28cfa3b8b5053d7f53a"
 }

package/ui/judgment-history.css

@@ -292,7 +292,7 @@
 }
 
 .bb-jh-ledger .bb-ws-ledger-row {
-  grid-template-columns: 92px minmax(0, 1fr) 250px 105px;
+  grid-template-columns: 92px minmax(0, 1fr) 250px 120px;
   align-items: center;
   min-height: 52px;
 }
@@ -581,7 +581,7 @@
   .bb-jh-ledger .bb-ws-ledger-row > span:nth-child(1)::before { content: '日時'; }
   .bb-jh-ledger .bb-ws-ledger-row > span:nth-child(2)::before { content: '行った判断'; }
   .bb-jh-ledger .bb-ws-ledger-row > span:nth-child(3)::before { content: '使った参照'; }
-  .bb-jh-ledger .bb-ws-ledger-row > span:nth-child(4)::before { content: '入口・状態'; }
+  .bb-jh-ledger .bb-ws-ledger-row > span:nth-child(4)::before { content: '判断したAI'; }
 }
 
 /* Compact workspace header, search controls and shared floating notifications. */
@@ -617,3 +617,156 @@
 }
 .bb-jh-notifications .bb-jh-banner.is-danger { border-left-color: var(--bb-color-notice-danger); }
 .bb-jh-notifications .bb-jh-banner-sources > span { white-space: normal; }
+
+/* Loading stays in the page, like the other workspace screens. */
+.bb-jh-loading { color: var(--bb-color-muted); }
+.bb-jh-summary-note { font-size: 11.5px; }
+.bb-jh-entrypoint { display: grid; gap: 2px; }
+.bb-jh-entrypoint small.bb-jh-waiting { color: var(--bb-color-warning-strong, var(--bb-color-accent-strong)); font-size: 11px; font-weight: 600; }
+.bb-jh-filter-fields .bb-jh-filter .bb-ws-combobox { width: 100%; }
+
+/* Detail: references that only have an id, the one question, and the record details. */
+.bb-jh-references { display: grid; gap: 8px; }
+.bb-jh-reference-list small { color: var(--bb-color-quiet); font-size: 11px; }
+.bb-jh-reference-kinds { margin: 0; color: var(--bb-color-ink); font-size: 13px; font-weight: 600; }
+.bb-jh-references .bb-jh-reference-note,
+.bb-jh-handoff .bb-jh-reference-note { margin: 0; }
+.bb-jh-feedback { display: grid; gap: 12px; }
+.bb-jh-feedback-events { display: grid; gap: 0; margin: 0; padding: 0; list-style: none; }
+.bb-jh-feedback-answers { display: flex; flex-wrap: wrap; gap: 6px; }
+.bb-jh-feedback-composer > .bb-ws-button { justify-self: start; }
+.bb-jh-record-details { margin-top: 10px; }
+.bb-jh-record-details > summary { color: var(--bb-color-muted); font-size: 12px; cursor: pointer; }
+.bb-jh-record-details[open] > summary { margin-bottom: 8px; }
+.bb-jh-record-details .bb-ws-definition dd { overflow-wrap: anywhere; }
+.bb-jh-id-list { display: grid; gap: 2px; margin: 0; padding: 0; list-style: none; font-family: var(--bb-font-mono); font-size: 10.5px; color: var(--bb-color-quiet); overflow-wrap: anywhere; }
+.bb-jh-handoff { display: grid; gap: 6px; margin-top: 14px; }
+.bb-jh-handoff h4 { margin: 0; font-size: 12.5px; color: var(--bb-color-ink); }
+.bb-jh-feedback-answers .bb-ws-button[aria-pressed="true"] { border-color: var(--bb-color-accent); background: var(--bb-color-accent-soft, #eeebfd); color: var(--bb-color-accent-strong, var(--bb-color-accent)); }
+.bb-jh-feedback-composer [data-action="submit-judgment-feedback"] { border-color: var(--bb-color-accent); background: var(--bb-color-accent); color: #fff; }
+.bb-jh-feedback-composer [data-action="submit-judgment-feedback"]:disabled { opacity: .55; cursor: default; }
+.bb-jh-feedback-composer textarea,
+.bb-jh-reference-export textarea { box-sizing: border-box; }
+
+/* 判断の根拠と本人の考え (story-judgment-history-frame-basis-v1) */
+.bb-jh-basis {
+  display: grid;
+  gap: 14px;
+}
+
+.bb-jh-basis-group {
+  display: grid;
+  gap: 6px;
+  min-width: 0;
+}
+
+.bb-jh-basis-group h4 {
+  margin: 0;
+  color: var(--bb-color-muted);
+  font-size: 11px;
+  font-weight: 680;
+  letter-spacing: 0.04em;
+}
+
+.bb-jh-basis-list {
+  display: grid;
+  gap: 10px;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.bb-jh-basis-list li {
+  display: grid;
+  gap: 3px;
+  min-width: 0;
+  padding-left: 10px;
+  border-left: 2px solid var(--bb-color-border);
+}
+
+.bb-jh-basis-list strong {
+  color: var(--bb-color-ink);
+  font-size: 13px;
+  line-height: 1.45;
+  overflow-wrap: anywhere;
+}
+
+.bb-jh-basis-list strong.bb-jh-unrecorded {
+  color: var(--bb-color-quiet);
+  font-weight: 500;
+}
+
+.bb-jh-basis-usage {
+  color: var(--bb-color-muted);
+  font-size: 12px;
+  line-height: 1.5;
+}
+
+.bb-jh-basis-usage.is-violated,
+.bb-jh-basis-usage.is-failed {
+  color: var(--bb-color-danger);
+}
+
+.bb-jh-basis-usage.is-tension {
+  color: var(--bb-color-warning);
+}
+
+.bb-jh-basis-usage.is-unrecorded {
+  color: var(--bb-color-quiet);
+}
+
+.bb-jh-basis-why {
+  color: var(--bb-color-muted);
+  font-size: 12px;
+  line-height: 1.5;
+}
+
+.bb-jh-basis-list small {
+  color: var(--bb-color-quiet);
+  font-size: 11px;
+}
+
+.bb-jh-owner {
+  display: grid;
+  gap: 4px;
+  padding: 10px 12px;
+  border: 1px solid var(--bb-color-border);
+  border-radius: var(--bb-radius-sm);
+  background: var(--bb-color-panel);
+}
+
+.bb-jh-owner.is-applied {
+  border-color: var(--bb-color-accent);
+  background: var(--bb-color-accent-soft);
+}
+
+.bb-jh-owner strong {
+  color: var(--bb-color-ink);
+  font-size: 13px;
+  line-height: 1.5;
+}
+
+.bb-jh-owner p {
+  margin: 0;
+  color: var(--bb-color-muted);
+  font-size: 12px;
+  line-height: 1.5;
+}
+
+.bb-jh-owner-badge {
+  width: fit-content;
+  padding: 1px 7px;
+  border: 1px solid var(--bb-color-border);
+  border-radius: 999px;
+  color: var(--bb-color-quiet);
+  font-size: 11px;
+  line-height: 1.6;
+  white-space: nowrap;
+}
+
+.bb-jh-owner-badge.is-applied {
+  border-color: var(--bb-color-accent);
+  background: var(--bb-color-accent-soft);
+  color: var(--bb-color-accent-strong);
+  font-weight: 680;
+}