@unson/brainbase-mcp 0.2.4 → 0.3.0

package/dist/templates.d.ts

@@ -1,4 +1,112 @@
-import type { GraphFile, RelationshipsFile } from './types.js';
-export declare const emptyGraph: GraphFile;
+import type { GraphFileV2, RelationshipsFile } from './types.js';
+export declare const canonicalGraphOntologyRelease: {
+    manifest: {
+        id: "brainbase-personal-os";
+        version: "2.0.0";
+        ontology: {
+            readonly version: "2.0.0";
+            readonly effectiveAt: "2026-08-17T00:00:00.000Z";
+            readonly compatibility: "read-compatible-write-gated";
+            readonly name: "Brainbase Portable Ontology Kernel";
+            readonly description: "A local-first semantic contract for canonical Graph entities and ID-based edges.";
+            readonly domains: {
+                readonly types: {
+                    readonly concepts: readonly [{
+                        readonly id: "person";
+                        readonly meaning: "A human represented in the local Graph.";
+                        readonly usageConditions: readonly ["Use only for a human identity approved for the canonical local SSOT."];
+                    }, {
+                        readonly id: "org";
+                        readonly meaning: "An organization represented in the local Graph.";
+                        readonly usageConditions: readonly ["Use for a named organizational actor, not for a project or product."];
+                    }, {
+                        readonly id: "project";
+                        readonly meaning: "A bounded body of work represented in the local Graph.";
+                        readonly usageConditions: readonly ["Use when the entity has a bounded work objective; do not use it as an organization alias."];
+                    }, {
+                        readonly id: "relationship";
+                        readonly meaning: "A contextual connection to a person.";
+                        readonly usageConditions: readonly ["The person field must resolve to a canonical person entity by name."];
+                    }, {
+                        readonly id: "decision";
+                        readonly meaning: "A durable choice that may explicitly supersede another choice.";
+                        readonly usageConditions: readonly ["Use for an explicit durable choice; replacement requires a supersedes Decision ID."];
+                    }];
+                };
+                readonly relations: {
+                    readonly vocabulary: {
+                        id: import("./types.js").CoreRelation;
+                        source: import("./types.js").CanonicalEntityKind;
+                        target: import("./types.js").CanonicalEntityKind;
+                    }[];
+                };
+                readonly constraints: {
+                    readonly rules: readonly [{
+                        readonly id: "ONT-ENTITY-ID-UNIQUE";
+                        readonly severity: "error";
+                        readonly meaning: "Graph entity IDs must be unique.";
+                    }, {
+                        readonly id: "ONT-RELATIONSHIP-ID-UNIQUE";
+                        readonly severity: "error";
+                        readonly meaning: "Relationship IDs must be unique.";
+                    }, {
+                        readonly id: "ONT-DECISION-ID-UNIQUE";
+                        readonly severity: "error";
+                        readonly meaning: "Decision IDs must be unique.";
+                    }, {
+                        readonly id: "ONT-RELATIONSHIP-PERSON-RESOLVES";
+                        readonly severity: "warning";
+                        readonly meaning: "A relationship person should resolve to a canonical person entity by name.";
+                    }, {
+                        readonly id: "ONT-DECISION-SUPERSEDES-EXISTS";
+                        readonly severity: "error";
+                        readonly meaning: "A supersedes reference must resolve to an existing decision.";
+                    }, {
+                        readonly id: "ONT-DECISION-SUPERSEDES-SELF";
+                        readonly severity: "error";
+                        readonly meaning: "A decision must not supersede itself.";
+                    }, {
+                        readonly id: "ONT-DECISION-SUPERSEDES-CYCLE";
+                        readonly severity: "error";
+                        readonly meaning: "Decision supersession edges must not form a cycle.";
+                    }];
+                };
+                readonly inference: {
+                    readonly rules: readonly [{
+                        readonly id: "ONT-INFER-EXPLICIT-SUPERSESSION";
+                        readonly meaning: "Only an explicit supersedes edge makes an older decision inactive.";
+                    }, {
+                        readonly id: "ONT-INFER-SAME-TOPIC-CONFLICT";
+                        readonly meaning: "Multiple active decisions on the same explicit topic are reported as a conflict.";
+                    }];
+                };
+                readonly evolution: {
+                    readonly compatibility: readonly [{
+                        readonly fromVersion: "0.0.0";
+                        readonly toVersion: "2.0.0";
+                        readonly level: "read-compatible-write-gated";
+                        readonly changes: readonly ["Adds a versioned public semantic contract.", "Adds canonical Graph v2 entities and ID-based edges governed by the Relation Registry."];
+                        readonly migration: "Before enabling 2.0.0 writes, back up the Personal OS directory, run ontology:audit, preview ontology:migrate, then write using the preview expectedInputDigest.";
+                        readonly rollback: "For an installation without a prior package, run npm uninstall -g @unson/brainbase-mcp, restore the captured MCP client configuration, and restart the client. Otherwise restore the pre-migration Personal OS backup and reinstall the recorded last known working package version.";
+                    }, {
+                        readonly fromVersion: "1.0.0";
+                        readonly toVersion: "2.0.0";
+                        readonly level: "read-compatible-write-gated";
+                        readonly changes: readonly ["Adds canonical Graph v2 entities and ID-based edges.", "Binds the portable ontology release to the canonical Relation Registry."];
+                        readonly migration: "Run ontology:audit --ontology-version 1.0.0, preview ontology:migrate, then write using the preview expectedInputDigest.";
+                        readonly rollback: "Restore the pre-migration Personal OS backup; the immutable 1.0.0 interpretation remains available for historical reads.";
+                    }];
+                };
+            };
+        };
+        relationRegistry: Readonly<Record<import("./types.js").CoreRelation, Readonly<import("./relation-registry.js").CanonicalRelationDefinition>>>;
+    };
+    binding: {
+        id: "brainbase-personal-os";
+        version: "2.0.0";
+        releaseDigest: string;
+    };
+};
+export declare const emptyGraph: GraphFileV2;
 export declare const emptyRelationships: RelationshipsFile;
 export declare const schemaTemplates: Record<string, unknown>;

package/dist/templates.js

@@ -1,21 +1,61 @@
+import { createHash } from 'node:crypto';
+import { portableOntology } from './ontology.js';
+import { canonicalRelationRegistry } from './relation-registry.js';
+const ontologyReleaseManifest = deepFreeze({
+    id: 'brainbase-personal-os',
+    version: portableOntology.version,
+    ontology: portableOntology,
+    relationRegistry: canonicalRelationRegistry
+});
+const ontologyReleaseDigest = `sha256:${createHash('sha256')
+    .update(JSON.stringify(ontologyReleaseManifest))
+    .digest('hex')}`;
+export const canonicalGraphOntologyRelease = deepFreeze({
+    manifest: ontologyReleaseManifest,
+    binding: {
+        id: ontologyReleaseManifest.id,
+        version: ontologyReleaseManifest.version,
+        releaseDigest: ontologyReleaseDigest
+    }
+});
 export const emptyGraph = {
-    version: 1,
+    version: 2,
+    ontology: canonicalGraphOntologyRelease.binding,
     owner: {},
-    entities: []
+    entities: [],
+    edges: []
 };
 export const emptyRelationships = {
     version: 1,
     relationships: []
 };
+function deepFreeze(value) {
+    if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+        Object.freeze(value);
+        for (const nested of Object.values(value))
+            deepFreeze(nested);
+    }
+    return value;
+}
 export const schemaTemplates = {
     'graph.schema.json': {
         type: 'object',
-        required: ['version', 'entities'],
+        required: ['version', 'ontology', 'entities', 'edges'],
         properties: {
-            version: { const: 1 },
+            version: { const: 2 },
+            ontology: {
+                type: 'object',
+                required: ['id', 'version', 'releaseDigest'],
+                properties: {
+                    id: { const: 'brainbase-personal-os' },
+                    version: { type: 'string', minLength: 1 },
+                    releaseDigest: { type: 'string', minLength: 1 }
+                }
+            },
             owner: {
                 type: 'object',
                 properties: {
+                    id: { type: 'string' },
                     name: { type: 'string' },
                     summary: { type: 'string' }
                 }
@@ -27,13 +67,42 @@ export const schemaTemplates = {
                     required: ['id', 'type', 'name'],
                     properties: {
                         id: { type: 'string', minLength: 1 },
-                        type: { enum: ['person', 'org', 'project', 'relationship'] },
+                        type: { enum: ['person', 'org', 'project', 'decision'] },
                         name: { type: 'string', minLength: 1 },
+                        aliases: { type: 'array', items: { type: 'string', minLength: 1 } },
                         summary: { type: 'string' },
                         tags: { type: 'array', items: { type: 'string' } },
                         metadata: { type: 'object' }
                     }
                 }
+            },
+            edges: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    required: ['id', 'fromId', 'relation', 'toId'],
+                    properties: {
+                        id: { type: 'string', minLength: 1 },
+                        fromId: { type: 'string', minLength: 1 },
+                        relation: {
+                            enum: ['member_of', 'participates_in', 'accountable_for', 'owned_by', 'governs', 'supersedes']
+                        },
+                        toId: { type: 'string', minLength: 1 },
+                        role: { type: 'string' },
+                        context: { type: 'string' },
+                        validFrom: { type: 'string', format: 'date-time' },
+                        validTo: { type: 'string', format: 'date-time' },
+                        provenance: {
+                            type: 'object',
+                            required: ['sourceKind'],
+                            properties: {
+                                sourceKind: { enum: ['user_approved', 'migration', 'import', 'onboarding'] },
+                                sourceId: { type: 'string' },
+                                evidenceHash: { type: 'string' }
+                            }
+                        }
+                    }
+                }
             }
         }
     },

package/dist/tools.d.ts

@@ -1,6 +1,10 @@
 import type { EntityKind, PersonalOs, SearchResult } from './types.js';
-export declare function getContext(os: PersonalOs): Record<string, unknown>;
+export interface RetrievalOptions {
+    project?: string;
+    asOf?: string;
+}
+export declare function getContext(os: PersonalOs, options?: RetrievalOptions): Record<string, unknown>;
 export declare function listEntities(os: PersonalOs, type?: EntityKind): Record<string, unknown>;
 export declare function searchPersonalKg(os: PersonalOs, query: string, limit?: number): SearchResult[];
-export declare function searchAll(os: PersonalOs, query: string, limit?: number): SearchResult[];
+export declare function searchAll(os: PersonalOs, query: string, limit?: number, options?: RetrievalOptions): SearchResult[];
 export declare function onboardingStatus(os: PersonalOs): Record<string, unknown>;

package/dist/tools.js

@@ -1,14 +1,16 @@
+import { isActiveAt } from './canonical-graph.js';
 import { buildOperationalizationPlan } from './operationalization.js';
-export function getContext(os) {
+import { getCanonicalRelation } from './relation-registry.js';
+export function getContext(os, options = {}) {
     const selfEntries = os.personalKg.filter((entry) => entry.type === 'self' || entry.type === 'value' || entry.type === 'judgment');
     const workEntries = os.personalKg.filter((entry) => entry.type === 'work' || entry.type === 'experience');
-    const projects = os.graph.entities.filter((entity) => entity.type === 'project').map((entity) => ({
-        id: entity.id,
-        name: entity.name,
-        summary: entity.summary,
-        goal: readMetadataString(entity.metadata, 'goal'),
-        status: readMetadataString(entity.metadata, 'status'),
-        role: readMetadataString(entity.metadata, 'role'),
+    const scoped = scopedRecords(os, options);
+    const visibleIds = os.graph.version === 2 ? new Set(scoped.records.map((record) => record.entity.id)) : undefined;
+    const projects = os.graph.entities
+        .filter((entity) => entity.type === 'project' && (!visibleIds || visibleIds.has(entity.id)))
+        .map((entity) => ({
+        id: entity.id, name: entity.name, summary: entity.summary,
+        goal: readMetadataString(entity.metadata, 'goal'), status: readMetadataString(entity.metadata, 'status'), role: readMetadataString(entity.metadata, 'role'),
         sources: Array.isArray(entity.metadata?.sources) ? entity.metadata.sources : [],
         taskSources: Array.isArray(entity.metadata?.taskSources) ? entity.metadata.taskSources : [],
         decisionPrinciples: Array.isArray(entity.metadata?.decisionPrinciples) ? entity.metadata.decisionPrinciples : []
@@ -17,175 +19,210 @@ export function getContext(os) {
         owner: os.graph.owner ?? {},
         self: selfEntries.map((entry) => entry.text),
         projects,
-        work: [
-            ...projects.map((project) => project.summary ? `${project.name}: ${project.summary}` : project.name),
-            ...workEntries.map((entry) => entry.text)
-        ],
-        relationships: os.relationships.relationships.map((relationship) => ({
-            person: relationship.person,
-            role: relationship.role,
-            context: relationship.context
-        })),
-        decisions: os.decisions.map((decision) => ({
-            title: decision.title,
-            decision: decision.decision,
-            rationale: decision.rationale
-        })),
+        work: [...projects.map((project) => project.summary ? `${project.name}: ${project.summary}` : project.name), ...workEntries.map((entry) => entry.text)],
+        relationships: os.relationships.relationships.map((relationship) => ({ person: relationship.person, role: relationship.role, context: relationship.context })),
+        decisions: os.decisions.map((decision) => ({ title: decision.title, decision: decision.decision, rationale: decision.rationale })),
         canonicalFiles: ['graph.json', 'personal-kg.jsonl', 'relationships.json', 'decisions.jsonl'],
-        note: 'Canonical local SSOT data is preferred over raw sources.'
+        note: 'Canonical local SSOT data is preferred over raw sources.',
+        ...(os.graph.version === 2 ? { canonicalGraph: {
+                schemaVersion: 2,
+                ontology: os.graph.ontology,
+                authority: 'local_graph',
+                asOf: scoped.asOf,
+                project: scoped.project ? { id: scoped.project.id, name: scoped.project.name } : null,
+                records: scoped.records.map(({ entity, relationPath }) => ({
+                    ...entity, canonicalEntityId: entity.id, recordClass: 'canonical', relationPath, authority: 'local_graph'
+                }))
+            } } : {})
     };
 }
 export function listEntities(os, type) {
     const graphEntities = os.graph.entities.filter((entity) => !type || entity.type === type);
-    const relationshipEntities = type && type !== 'relationship'
-        ? []
-        : os.relationships.relationships.map((relationship) => ({
-            id: relationship.id,
-            type: 'relationship',
-            name: relationship.person,
-            summary: relationship.context,
-            tags: relationship.tags
-        }));
-    const decisionEntities = type && type !== 'decision'
-        ? []
-        : os.decisions.map((decision) => ({
-            id: decision.id,
-            type: 'decision',
-            name: decision.title,
-            summary: decision.decision,
-            tags: decision.tags
-        }));
-    return {
-        entities: [...graphEntities, ...relationshipEntities, ...decisionEntities]
-    };
+    const relationshipEntities = type && type !== 'relationship' ? [] : os.relationships.relationships.map((relationship) => ({
+        id: relationship.id, type: 'relationship', name: relationship.person, summary: relationship.context, tags: relationship.tags
+    }));
+    const decisionEntities = type && type !== 'decision' ? [] : os.decisions.map((decision) => ({
+        id: decision.id, type: 'decision', name: decision.title, summary: decision.decision, tags: decision.tags
+    }));
+    return { entities: [...graphEntities, ...relationshipEntities, ...decisionEntities] };
 }
 export function searchPersonalKg(os, query, limit = 10) {
     return rank(os.personalKg.map((entry) => ({
-        source: 'personal-kg',
-        id: entry.id,
-        title: entry.type,
-        text: entry.text,
-        score: scoreText(query, [entry.id, entry.type, entry.text, ...(entry.tags ?? [])])
+        source: 'personal-kg', id: entry.id, title: entry.type, text: entry.text,
+        score: scoreText(query, [entry.id, entry.type, entry.text, ...(entry.tags ?? [])]),
+        recordClass: 'unresolved', authority: 'personal_kg'
     })), limit);
 }
-export function searchAll(os, query, limit = 10) {
-    const graphResults = os.graph.entities.map((entity) => ({
-        source: 'graph',
-        id: entity.id,
-        title: entity.name,
+export function searchAll(os, query, limit = 10, options = {}) {
+    const scoped = scopedRecords(os, options);
+    const graphRecords = os.graph.version === 2
+        ? scoped.records
+        : os.graph.entities.map((entity) => ({ entity: entity, relationPath: [] }));
+    const graphResults = graphRecords.map(({ entity, relationPath }) => ({
+        source: 'graph', id: entity.id, title: entity.name,
         text: [entity.summary ?? entity.name, metadataText(entity.metadata)].filter(Boolean).join('\n'),
-        score: scoreText(query, [entity.id, entity.type, entity.name, entity.summary ?? '', metadataText(entity.metadata), ...(entity.tags ?? [])])
+        score: scoreText(query, [entity.id, entity.type, entity.name, ...(entity.aliases ?? []), entity.summary ?? '', metadataText(entity.metadata), ...(entity.tags ?? [])]),
+        canonicalEntityId: entity.id, recordClass: 'canonical', relationPath, authority: 'local_graph'
     }));
-    const relationshipResults = os.relationships.relationships.map((relationship) => ({
-        source: 'relationships',
-        id: relationship.id,
-        title: relationship.person,
-        text: relationship.context,
-        score: scoreText(query, [relationship.id, relationship.person, relationship.role ?? '', relationship.context, ...(relationship.tags ?? [])])
-    }));
-    const decisionResults = os.decisions.map((decision) => ({
-        source: 'decisions',
-        id: decision.id,
-        title: decision.title,
-        text: [decision.decision, decision.rationale ?? ''].filter(Boolean).join('\n'),
-        score: scoreText(query, [decision.id, decision.title, decision.decision, decision.rationale ?? '', ...(decision.tags ?? [])])
-    }));
-    return rank([...graphResults, ...searchPersonalKg(os, query, limit), ...relationshipResults, ...decisionResults], limit);
+    const visibleIds = new Set(scoped.records.map((record) => record.entity.id));
+    const targets = os.graph.version === 2 ? projectionTargets(os.graph, scoped.asOf, visibleIds) : undefined;
+    const relationshipResults = os.relationships.relationships.map((relationship) => {
+        const projectionOf = targets?.person.get(normalize(relationship.person));
+        return {
+            source: 'relationships', id: relationship.id, title: relationship.person, text: relationship.context,
+            score: scoreText(query, [relationship.id, relationship.person, relationship.role ?? '', relationship.context, ...(relationship.tags ?? [])]),
+            ...(projectionOf ? { canonicalEntityId: projectionOf, projectionOf } : {}),
+            recordClass: projectionOf ? 'projection' : 'unresolved', authority: 'legacy_relationships'
+        };
+    });
+    const decisionResults = os.decisions.map((decision) => {
+        const projectionOf = targets?.decision.get(decision.id) ?? targets?.decision.get(normalize(decision.title));
+        return {
+            source: 'decisions', id: decision.id, title: decision.title,
+            text: [decision.decision, decision.rationale ?? ''].filter(Boolean).join('\n'),
+            score: scoreText(query, [decision.id, decision.title, decision.decision, decision.rationale ?? '', ...(decision.tags ?? [])]),
+            ...(projectionOf ? { canonicalEntityId: projectionOf, projectionOf } : {}),
+            recordClass: projectionOf ? 'projection' : 'unresolved', authority: 'legacy_decisions'
+        };
+    });
+    const additional = [...relationshipResults, ...decisionResults, ...(options.project ? [] : searchPersonalKg(os, query, limit))]
+        .filter((result) => !options.project || Boolean(result.projectionOf));
+    const canonicalById = new Map(graphResults.map((result) => [result.id, result]));
+    const retained = [];
+    for (const result of additional) {
+        const canonical = result.projectionOf ? canonicalById.get(result.projectionOf) : undefined;
+        if (canonical) {
+            canonical.score = Math.max(canonical.score, result.score);
+            if (result.source === 'relationships' || result.source === 'decisions') {
+                canonical.projectionSources = [...new Set([...(canonical.projectionSources ?? []), result.source])];
+            }
+        }
+        else
+            retained.push(result);
+    }
+    return rank([...graphResults, ...retained], limit);
 }
 export function onboardingStatus(os) {
     const seeded = {
         self: Boolean(os.graph.owner?.name) || os.personalKg.some((entry) => entry.type === 'self'),
         work: os.graph.entities.some((entity) => entity.type === 'project') || os.personalKg.some((entry) => entry.type === 'work'),
-        relationships: os.relationships.relationships.length > 0
+        relationships: os.relationships.relationships.length > 0 || (os.graph.version === 2 && os.graph.edges.length > 0)
     };
-    const missing = Object.entries(seeded)
-        .filter(([, value]) => !value)
-        .map(([key]) => key);
+    const missing = Object.entries(seeded).filter(([, value]) => !value).map(([key]) => key);
     const valueDemoReady = missing.length === 0;
-    const operationalization = buildOperationalizationPlan({
-        dataDir: os.dataDir,
-        firstValueReady: valueDemoReady
-    });
+    const operationalization = buildOperationalizationPlan({ dataDir: os.dataDir, firstValueReady: valueDemoReady });
     return {
-        dataDir: os.dataDir,
-        localBackend: {
-            connected: true,
-            backend: 'local'
-        },
-        agentMcp: {
-            status: 'not_verified',
-            verification: 'MCP設定を反映した新しいエージェントセッションで get_context / search を確認してください。'
-        },
-        operationallyReady: false,
-        seeded,
-        missing,
-        valueDemo: {
-            scope: 'local_cli_sample',
-            ready: valueDemoReady,
-            missing,
-            command: `brainbase onboard:demo --dir ${shellArg(os.dataDir)} --scenario "<real request>"`,
-            completionSignal: valueDemoReady ? 'cli_sample_ready' : 'needs_seed'
-        },
+        dataDir: os.dataDir, localBackend: { connected: true, backend: 'local' },
+        agentMcp: { status: 'not_verified', verification: 'MCP設定を反映した新しいエージェントセッションで resolve_entity / get_context / search を確認してください。' },
+        operationallyReady: false, seeded, missing,
+        valueDemo: { scope: 'local_cli_sample', ready: valueDemoReady, missing, command: `brainbase onboard:demo --dir ${shellArg(os.dataDir)} --scenario "<real request>"`, completionSignal: valueDemoReady ? 'cli_sample_ready' : 'needs_seed' },
         operationalization,
-        counts: {
-            graphEntities: os.graph.entities.length,
-            personalKgEntries: os.personalKg.length,
-            relationships: os.relationships.relationships.length,
-            decisions: os.decisions.length,
-            rawSources: os.sourceCount
-        }
+        counts: { graphEntities: os.graph.entities.length, graphEdges: os.graph.version === 2 ? os.graph.edges.length : 0, personalKgEntries: os.personalKg.length, relationships: os.relationships.relationships.length, decisions: os.decisions.length, rawSources: os.sourceCount }
+    };
+}
+function scopedRecords(os, options) {
+    const asOf = options.asOf ?? new Date().toISOString();
+    if (os.graph.version !== 2)
+        return { records: [], asOf };
+    const graph = os.graph;
+    const active = graph.entities.filter((entity) => isActiveAt(entity, asOf));
+    const activeIds = new Set(active.map((entity) => entity.id));
+    const project = options.project ? resolveProject(active, options.project) : undefined;
+    if (options.project && !project)
+        return { records: [], asOf };
+    if (!project)
+        return { records: active.map((entity) => ({ entity, relationPath: [] })), asOf };
+    const edges = graph.edges.filter((edge) => isActiveAt(edge, asOf) && activeIds.has(edge.fromId) && activeIds.has(edge.toId));
+    return {
+        records: active.flatMap((entity) => {
+            const relationPath = pathToProject(entity.id, project.id, edges);
+            return relationPath === undefined ? [] : [{ entity, relationPath }];
+        }), project, asOf
     };
 }
-function shellArg(value) {
-    return /^[A-Za-z0-9_./:@%+=,-]+$/.test(value) ? value : JSON.stringify(value);
+function pathToProject(entityId, projectId, edges) {
+    if (entityId === projectId)
+        return [];
+    const queue = [{ id: entityId, path: [] }];
+    const visited = new Set([entityId]);
+    while (queue.length > 0) {
+        const current = queue.shift();
+        for (const edge of edges) {
+            const relation = getCanonicalRelation(edge.relation);
+            if (relation.scopeTraversal === 'none' || relation.traversalDirection === 'none')
+                continue;
+            const next = relation.traversalDirection === 'forward' ? (edge.fromId === current.id ? edge.toId : undefined) : (edge.toId === current.id ? edge.fromId : undefined);
+            if (!next)
+                continue;
+            const path = [...current.path, edge.id];
+            if (next === projectId)
+                return path;
+            if (relation.scopeTraversal === 'project_transitive' && !visited.has(next)) {
+                visited.add(next);
+                queue.push({ id: next, path });
+            }
+        }
+    }
+    return undefined;
+}
+function resolveProject(entities, value) {
+    const needle = normalize(value);
+    const matches = entities.filter((entity) => entity.type === 'project' && [entity.id, entity.name, ...(entity.aliases ?? [])].some((candidate) => normalize(candidate) === needle));
+    return matches.length === 1 ? matches[0] : undefined;
+}
+function projectionTargets(graph, asOf, visibleIds) {
+    const person = new Map();
+    const decision = new Map();
+    const ambiguous = new Set();
+    for (const entity of graph.entities.filter((candidate) => visibleIds.has(candidate.id) && isActiveAt(candidate, asOf))) {
+        const target = entity.type === 'person' ? person : entity.type === 'decision' ? decision : undefined;
+        if (!target)
+            continue;
+        for (const value of [entity.id, entity.name, ...(entity.aliases ?? [])]) {
+            const key = value === entity.id ? value : normalize(value);
+            if (target.has(key) && target.get(key) !== entity.id)
+                ambiguous.add(`${entity.type}:${key}`);
+            else
+                target.set(key, entity.id);
+        }
+    }
+    for (const marker of ambiguous) {
+        const [kind, ...parts] = marker.split(':');
+        (kind === 'person' ? person : decision).delete(parts.join(':'));
+    }
+    return { person, decision };
 }
 function rank(results, limit) {
-    return results
-        .filter((result) => result.score > 0)
-        .sort((a, b) => b.score - a.score || a.title.localeCompare(b.title))
+    const priority = { canonical: 0, projection: 1, unresolved: 2 };
+    return results.filter((result) => result.score > 0)
+        .sort((a, b) => b.score - a.score || priority[a.recordClass] - priority[b.recordClass] || a.title.localeCompare(b.title))
         .slice(0, Math.max(1, limit));
 }
 function scoreText(query, fields) {
-    const terms = searchTokens(query);
-    if (terms.length === 0) {
-        return 0;
-    }
-    const haystack = fields.join('\n').toLowerCase();
-    const phrase = query.trim().toLowerCase();
-    const matchedTerms = terms.filter((term) => haystack.includes(term));
-    if (phrase && haystack.includes(phrase)) {
-        return terms.length + 20;
+    let best = 0;
+    for (const variant of queryAliases(query)) {
+        const terms = searchTokens(variant);
+        if (terms.length === 0)
+            continue;
+        const haystack = fields.join('\n').normalize('NFKC').toLowerCase();
+        const phrase = variant.trim().normalize('NFKC').toLowerCase();
+        const matched = terms.filter((term) => haystack.includes(term));
+        best = Math.max(best, phrase && haystack.includes(phrase) ? terms.length + 20 : matched.length === terms.length ? terms.length + 10 : matched.length);
     }
-    if (matchedTerms.length === terms.length) {
-        return terms.length + 10;
-    }
-    return matchedTerms.length;
+    return best;
+}
+function queryAliases(query) {
+    const canonical = query.normalize('NFKC').trim();
+    const alias = canonical.replace(/(?:さん|様|氏|くん|君|ちゃん)$/u, '').trim();
+    return alias && alias !== canonical ? [canonical, alias] : [canonical];
 }
 function searchTokens(query) {
     const seen = new Set();
-    return query
-        .normalize('NFKC')
-        .replace(/[|/\\,;:()[\]{}"'`“”‘’、。・･，．：；（）［］｛｝「」『』【】]/g, ' ')
-        .replace(/[-_]+/g, ' ')
-        .toLowerCase()
-        .split(/\s+/)
-        .map((term) => term.trim())
-        .filter(Boolean)
-        .filter((term) => {
-        if (seen.has(term)) {
-            return false;
-        }
-        seen.add(term);
-        return true;
-    });
-}
-function metadataText(metadata) {
-    if (!metadata) {
-        return '';
-    }
-    return JSON.stringify(metadata);
-}
-function readMetadataString(metadata, key) {
-    const value = metadata?.[key];
-    return typeof value === 'string' ? value : undefined;
+    return query.normalize('NFKC').replace(/[|/\\,;:()[\]{}"'`“”‘’、。・･，．：；（）［］｛｝「」『』【】]/g, ' ')
+        .replace(/[-_]+/g, ' ').toLowerCase().split(/\s+/).map((term) => term.trim()).filter(Boolean)
+        .filter((term) => seen.has(term) ? false : (seen.add(term), true));
 }
+function normalize(value) { return value.normalize('NFKC').replace(/\s+/g, '').toLowerCase(); }
+function metadataText(metadata) { return metadata ? JSON.stringify(metadata) : ''; }
+function readMetadataString(metadata, key) { const value = metadata?.[key]; return typeof value === 'string' ? value : undefined; }
+function shellArg(value) { return /^[A-Za-z0-9_./:@%+=,-]+$/.test(value) ? value : JSON.stringify(value); }