@unson/brainbase-mcp 0.19.0 → 0.21.0

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

@@ -27,6 +27,8 @@ export interface CanonicalTaskRecord extends JsonRecord {
     completed_at?: string | null;
     source_refs?: unknown[];
     project_codes?: string[];
+    /** What the work is for, in a few words (one per task); null when unlabelled. */
+    purpose_label?: string | null;
     created_at?: string | null;
     updated_at?: string | null;
     web_url?: string | null;
@@ -41,6 +43,7 @@ export interface CanonicalTaskCreateInput extends JsonRecord {
     review_at?: string | null;
     source_refs?: unknown[];
     project_codes?: unknown;
+    purpose_label?: string | null;
 }
 export interface CanonicalTaskUpdateInput extends JsonRecord {
     title?: string;
@@ -52,6 +55,7 @@ export interface CanonicalTaskUpdateInput extends JsonRecord {
     review_at?: string | null;
     source_refs?: unknown[];
     project_codes?: unknown;
+    purpose_label?: string | null;
 }
 export interface CanonicalTaskListFilters extends JsonRecord {
     statuses?: unknown;

package/dist/canonical-task-service.js

@@ -35,6 +35,7 @@ const CREATE_FIELDS = new Set([
     'review_at',
     'source_refs',
     'project_codes',
+    'purpose_label',
 ]);
 const MUTABLE_FIELDS = new Set([
     'expected_version',
@@ -47,6 +48,7 @@ const MUTABLE_FIELDS = new Set([
     'review_at',
     'source_refs',
     'project_codes',
+    'purpose_label',
 ]);
 function fail(code, message, status = 400, details = {}) {
     throw new CanonicalTaskError(code, message, status, details);
@@ -72,6 +74,11 @@ function normalizeString(value, field, options = {}) {
     }
     return normalized;
 }
+/** 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) {
+    return normalizeString(value, 'purpose_label', { max: MAX_PURPOSE_LABEL_LENGTH });
+}
 function normalizeIsoDate(value, field) {
     const text = normalizeString(value, field);
     if (text == null)
@@ -627,6 +634,7 @@ export class CanonicalTaskService {
         const priority = input.priority == null || input.priority === '' ? 'medium' : String(input.priority);
         if (!isCanonicalTaskPriority(priority))
             fail('validation_error', 'priority is invalid', 400, { field: 'priority' });
+        const purposeLabel = normalizePurposeLabel(input.purpose_label);
         return {
             title,
             description: normalizeString(input.description, 'description', { max: 10000, multiline: true }),
@@ -637,6 +645,8 @@ export class CanonicalTaskService {
             review_at: normalizeIsoDate(input.review_at, 'review_at'),
             source_refs: normalizeSourceRefs(input.source_refs) ?? [],
             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 } : {}),
         };
     }
     normalizeUpdateInput(input) {
@@ -668,6 +678,8 @@ export class CanonicalTaskService {
             patch.source_refs = normalizeSourceRefs(input.source_refs) ?? [];
         if ('project_codes' in input)
             patch.project_codes = normalizeProjectCodes(input.project_codes) ?? [];
+        if ('purpose_label' in input)
+            patch.purpose_label = normalizePurposeLabel(input.purpose_label);
         if (Object.keys(patch).length === 0)
             fail('validation_error', 'Task update must include at least one mutable field');
         return patch;
@@ -843,6 +855,8 @@ export class CanonicalTaskService {
             response.source_refs = [];
         if (response.project_codes === undefined)
             response.project_codes = [];
+        if (response.purpose_label === undefined)
+            response.purpose_label = null;
         return response;
     }
 }

package/dist/local-web-host.js

@@ -693,6 +693,7 @@ export function createGraphWebModule(context) {
             'graph-own-share.js',
             'graph-projects-view.css',
             'project-workspace.js',
+            'project-overview.js',
             'project-workspace.css',
             'project-graph.js',
             'project-graph-entry.js',

package/dist/world-extension.d.ts

@@ -1,6 +1,7 @@
 import { JudgmentValueProofJournalCache } from './judgment-value-proof-review.js';
 import { type GraphVocabularyTerm, type LocalWebExtension, type LocalWebModuleContext } from './local-web-host.js';
 import type { GraphFileV2 } from './types.js';
+export * from './world-work.js';
 /**
  * World view (ledger P17, adopted 2026-10-04): the home's upper layer.
  *
@@ -177,4 +178,3 @@ export declare function readJudgmentPlaces(journalRoot: string, options?: {
 export declare function createWorldExtension(options?: {
     readonly vocabulary?: WorldVocabularyConfig;
 }): LocalWebExtension;
-export {};

package/dist/world-extension.js

@@ -5,6 +5,8 @@ import { projectOrganizationGraph, projectVocabularyTerms } from './organization
 import { readLocalGraphState } from './local-web-host.js';
 import { loadPersonalOs } from './ssot.js';
 import { requestUrl, writeJson } from './local-web-security.js';
+import { WORLD_WORK_VERSION } from './world-work.js';
+export * from './world-work.js';
 /**
  * World view (ledger P17, adopted 2026-10-04): the home's upper layer.
  *
@@ -325,6 +327,13 @@ function createWorldModule(context, read) {
                 writeJson(response, 200, await read());
                 return true;
             }
+            // This Mac keeps no Canonical Task store, so the work inside a city is not connected here
+            // (an organization web answers these from its Task API).  Said as a state, never as no work.
+            if (path === `/api/extensions/${WORLD_EXTENSION_ID}/work-summary` || /^\/api\/extensions\/world\/businesses\/[^/]+\/work$/u.test(path)) {
+                response.setHeader('Cache-Control', 'no-store');
+                writeJson(response, 200, { status: 'not_connected', version: WORLD_WORK_VERSION, reason: 'task_store_not_connected' });
+                return true;
+            }
             if (path === `/api/extensions/${WORLD_EXTENSION_ID}/judgment-places`) {
                 response.setHeader('Cache-Control', 'no-store');
                 writeJson(response, 200, { version: WORLD_EXTENSION_VERSION, ...(await readJudgmentPlaces(context.journalRoot, { cache: context.journalCache, workspaces })) });
@@ -338,7 +347,7 @@ export function createWorldExtension(options = {}) {
     return {
         id: WORLD_EXTENSION_ID,
         uiDir: fileURLToPath(new URL('../ui/world/', import.meta.url)),
-        uiFiles: ['world-view.js', 'world-view.css', 'world-vendor.js', 'world-placement.js'],
+        uiFiles: ['world-view.js', 'world-view.css', 'world-vendor.js', 'world-placement.js', 'world-work-rail.js', 'world-district.js'],
         screenEntry: 'world-view.js',
         // P17: the world sits above the home and opens first.
         navPosition: 'first',

package/dist/world-work.d.ts

@@ -0,0 +1,248 @@
+/**
+ * The work inside a city of the world (story-world-work-sites-and-gaps-v1).
+ *
+ * A pure projection of what the host read with the member's grants: the
+ * business's Canonical Tasks (Task API) and, from the organization Graph, its
+ * people, decisions and relations.  Two things are kept apart throughout:
+ *
+ *   - the work as recorded (A): a task's `status` and `waiting_on`, as written;
+ *   - what we can see of it (B): gaps found only from structured fields
+ *     (an empty assignee field, no source link, a review date passed), never
+ *     from reading the free text as a judgment of the work.
+ *
+ * A gap says what is known, what is not connected or not confirmed, where it
+ * comes from and when, and what to check next.  Nothing here concludes that
+ * work has stopped, and nothing unreadable becomes zero.
+ */
+export declare const WORLD_WORK_VERSION: "world-work.v1";
+export type WorldWorkReadState = 'complete' | 'partial' | 'failed' | 'forbidden' | 'not_connected';
+export interface WorldWorkRead<T = unknown> {
+    readonly state: WorldWorkReadState;
+    readonly read_at?: string | null;
+    readonly reason?: string | null;
+    readonly items?: readonly T[];
+}
+export type WorldWorkStatus = 'pending' | 'in_progress' | 'waiting' | 'completed' | 'cancelled';
+export type WorldWorkGapKind = 'assignee_unlinked_mentioned' | 'assignee_unrecorded' | 'source_unlinked' | 'outcome_unlinked' | 'review_overdue';
+export declare const WORLD_WORK_GAP_KINDS: readonly WorldWorkGapKind[];
+export declare const WORLD_WORK_GAP_LABELS: Readonly<Record<WorldWorkGapKind, string>>;
+export type WorldWorkLink = 'recorded' | 'inferred' | 'unreadable';
+export interface WorldWorkSource {
+    readonly system: 'task_api' | 'organization_graph';
+    readonly record_id: string;
+    readonly fields: readonly string[];
+}
+export interface WorldWorkPersonRef {
+    readonly person_id: string | null;
+    readonly name: string;
+}
+export interface WorldWorkGap {
+    readonly kind: WorldWorkGapKind;
+    readonly label: string;
+    /** What the records do say. */
+    readonly fact: string;
+    /** What is not connected or not confirmed, and how far that reaches. */
+    readonly unknown: string;
+    /** What to check next to see further.  Never a task to create. */
+    readonly next_check: string;
+    /** Who could answer, when the records name someone; null when they do not. */
+    readonly check_with: WorldWorkPersonRef | null;
+    readonly source: WorldWorkSource;
+    /** The newest check the record itself notes (a dated note in its text), else its last update. */
+    readonly checked_at: string | null;
+    readonly checked_at_basis: 'text_note' | 'updated_at' | null;
+}
+export interface WorldWorkPersonLink extends WorldWorkPersonRef {
+    readonly link: Exclude<WorldWorkLink, 'unreadable'>;
+    readonly basis: 'assignee_field' | 'text_person_id' | 'text_full_name';
+    /** The text puts 「担当」 right before the person (e.g. 実担当は…).  Still not the assignee field. */
+    readonly stated_as_assignee?: boolean;
+}
+/** Words in the text that match more than one Graph person: left undecided, never picked. */
+export interface WorldWorkAmbiguousMention {
+    readonly text: string;
+    readonly candidates: readonly WorldWorkPersonRef[];
+}
+export interface WorldWorkSite {
+    readonly task_id: string;
+    readonly title: string;
+    /** What the work is for, as the task record states it (`purpose_label`); null when it states none. */
+    readonly purpose_label: string | null;
+    readonly project_codes: readonly string[];
+    /** Codes of other visible businesses this task also belongs to (work across a boundary). */
+    readonly other_business_codes: readonly string[];
+    readonly work: {
+        readonly status: WorldWorkStatus | null;
+        readonly label: string;
+        readonly open: boolean;
+        readonly waiting_on: string | null;
+        readonly due_at: string | null;
+        readonly past_due: boolean;
+        readonly review_at: string | null;
+        readonly created_at: string | null;
+        readonly updated_at: string | null;
+        readonly completed_at: string | null;
+    };
+    readonly people: readonly WorldWorkPersonLink[];
+    readonly ambiguous_mentions: readonly WorldWorkAmbiguousMention[];
+    readonly source_refs: readonly {
+        readonly type: string | null;
+        readonly url: string | null;
+        readonly label: string;
+    }[];
+    /** The completion condition the text states, quoted; null when it states none. */
+    readonly expected_outcome: string | null;
+    /** Dated check notes in the text, newest first. */
+    readonly audit_notes: readonly {
+        readonly date: string;
+        readonly text: string;
+    }[];
+    readonly gaps: readonly WorldWorkGap[];
+    readonly description: string | null;
+    readonly source: WorldWorkSource & {
+        readonly version: number | null;
+        readonly web_url: string | null;
+    };
+}
+export interface WorldWorkRelation {
+    readonly link: WorldWorkLink;
+    /** What the relation is, in plain words. */
+    readonly label: string;
+    readonly kind: string;
+    readonly counterpart: {
+        readonly id: string | null;
+        readonly type: string | null;
+        readonly name: string;
+    } | null;
+    /** The counterpart is another business of this world (drawn as a road between cities). */
+    readonly business_code: string | null;
+    readonly direction: 'incoming' | 'outgoing' | null;
+    readonly basis: string;
+    readonly source: WorldWorkSource | null;
+    /** Tasks that carry this relation (people named in tasks). */
+    readonly task_ids: readonly string[];
+}
+export interface WorldWorkPolicy {
+    readonly decision_id: string;
+    readonly title: string;
+    readonly decided_at: string | null;
+    readonly link: Exclude<WorldWorkLink, 'unreadable'>;
+    readonly basis: string;
+    readonly scope_code: string | null;
+}
+export interface WorldWorkSummary {
+    readonly business_code: string;
+    readonly state: WorldWorkReadState;
+    readonly read_at: string | null;
+    readonly reason: string | null;
+    /** Counts only when the tasks were read; null otherwise (not zero). */
+    readonly open: number | null;
+    readonly total: number | null;
+    readonly by_status: Readonly<Partial<Record<WorldWorkStatus | 'unknown', number>>> | null;
+    /** For each kind of gap, the open tasks that show it: the reason behind every count. */
+    readonly gaps: Readonly<Partial<Record<WorldWorkGapKind, readonly string[]>>> | null;
+    /** Open tasks with at least one gap. */
+    readonly needs_check: readonly string[] | null;
+}
+export interface WorldWorkReads {
+    readonly tasks: {
+        readonly state: WorldWorkReadState;
+        readonly read_at: string | null;
+        readonly reason: string | null;
+        readonly count: number | null;
+    };
+    readonly persons: {
+        readonly state: WorldWorkReadState;
+        readonly reason: string | null;
+    };
+    readonly decisions: {
+        readonly state: WorldWorkReadState;
+        readonly reason: string | null;
+    };
+    readonly relations: {
+        readonly state: WorldWorkReadState;
+        readonly reason: string | null;
+    };
+}
+export type WorldWorkResponse = {
+    readonly status: 'ok';
+    readonly version: typeof WORLD_WORK_VERSION;
+    readonly as_of: string;
+    readonly business: {
+        readonly id: string;
+        readonly code: string;
+        readonly name: string;
+    };
+    readonly reads: WorldWorkReads;
+    readonly purpose: {
+        readonly text: string | null;
+        readonly state: 'registered' | 'unregistered';
+        readonly summary: string | null;
+        readonly policies: readonly WorldWorkPolicy[];
+    };
+    readonly people: readonly (WorldWorkPersonRef & {
+        readonly roles: readonly string[];
+        readonly link: Exclude<WorldWorkLink, 'unreadable'>;
+        readonly task_ids: readonly string[];
+    })[];
+    readonly members_state: 'registered' | 'unregistered' | 'unreadable';
+    readonly relations: readonly WorldWorkRelation[];
+    readonly sites: readonly WorldWorkSite[];
+    readonly summary: WorldWorkSummary;
+} | {
+    readonly status: 'not_connected' | 'unavailable' | 'forbidden' | 'not_found';
+    readonly version: typeof WORLD_WORK_VERSION;
+    readonly reason: string;
+};
+export interface WorldWorkBusinessInput {
+    readonly id: string;
+    readonly code: string;
+    readonly name: string;
+    readonly summary?: string | null;
+    readonly purpose?: string | null;
+    readonly aliases?: readonly string[];
+    /** Codes of this business's engagements: their tasks are this city's work too. */
+    readonly engagement_codes?: readonly string[];
+}
+export interface WorldWorkProjectInput {
+    readonly owner?: WorldWorkPersonRef | null;
+    readonly people?: readonly (WorldWorkPersonRef & {
+        readonly roles: readonly string[];
+    })[];
+    readonly members_state?: 'registered' | 'unregistered' | 'unreadable';
+    /** Decisions the business's own records cite as their source (`source_decision_ids`, merged records included). */
+    readonly source_decision_ids?: readonly string[];
+    /** Aliases of terms the Graph records as belonging to this business (used only to infer, never to record). */
+    readonly term_aliases?: readonly {
+        readonly term: string;
+        readonly alias: string;
+    }[];
+}
+/** Other businesses of the world, to name a counterpart city and tasks that cross a boundary. */
+export interface WorldWorkNeighbour {
+    readonly id: string;
+    readonly code: string;
+    readonly name: string;
+    readonly engagement_codes?: readonly string[];
+    readonly record_ids?: readonly string[];
+}
+/** Per business, what the world shows above the city: counts with the tasks behind them. */
+export declare function summarizeWorldWork(input: {
+    readonly businesses: readonly WorldWorkNeighbour[];
+    readonly tasks: Readonly<Record<string, WorldWorkRead>>;
+    readonly persons?: WorldWorkRead;
+}, options?: {
+    readonly now?: Date;
+}): Readonly<Record<string, WorldWorkSummary>>;
+/** The work of one business for its city: sites, purpose, people, relations and the summary. */
+export declare function projectWorldWork(input: {
+    readonly business: WorldWorkBusinessInput;
+    readonly tasks: WorldWorkRead;
+    readonly persons?: WorldWorkRead;
+    readonly decisions?: WorldWorkRead;
+    readonly relations?: WorldWorkRead;
+    readonly project?: WorldWorkProjectInput;
+    readonly neighbours?: readonly WorldWorkNeighbour[];
+}, options?: {
+    readonly now?: Date;
+}): WorldWorkResponse;