@unson/brainbase-mcp 0.1.0

package/dist/onboarding.js

@@ -0,0 +1,1061 @@
+import { buildOperationalizationPlan } from './operationalization.js';
+export function buildAgentOnboardingProtocol() {
+    return {
+        goal: 'Help the user reach a first useful Brainbase answer from local canonical context before asking them to configure source collectors.',
+        interviewSections: [
+            {
+                id: 'value_target',
+                title: 'First value target',
+                questions: [
+                    'What do you not want to explain repeatedly to Codex, Claude Code, or CodeCode?',
+                    'Which real request would prove Brainbase is useful today?',
+                    'Should the first demo focus on a work premise, key relationship, decision principle, or active project?'
+                ]
+            },
+            {
+                id: 'hypothesis',
+                title: 'Memory hypothesis',
+                questions: [
+                    'Summarize the smallest self, work, and relationship facts needed for that demo.',
+                    'State what Brainbase should remember in plain language before writing any files.',
+                    'Name the relationship or project the demo should use.'
+                ]
+            },
+            {
+                id: 'approval',
+                title: 'Approval',
+                questions: [
+                    'Ask the user to approve the exact facts that Brainbase will save locally.',
+                    'Confirm that the facts are safe to store locally under the Personal OS directory.',
+                    'Do not show candidate JSON as the first user-facing review surface.'
+                ]
+            },
+            {
+                id: 'minimum_seed',
+                title: 'Minimum canonical seed',
+                questions: [
+                    'Run brainbase onboard:init if the Personal OS directory does not exist.',
+                    'Run brainbase onboard:seed with the approved name, value, project, relationship, or decision principle.',
+                    'Keep raw sources and candidates out of the first value demo.'
+                ]
+            },
+            {
+                id: 'first_value_demo',
+                title: 'First value demo',
+                questions: [
+                    'Run brainbase onboard:demo with the real request the user chose.',
+                    'Show the try-this prompt, sample result, and what the user did not have to explain again.',
+                    'Treat the useful output, not ready=true or connector readiness, as the onboarding completion signal.',
+                    'After showing the useful output, report the remaining operationalization actions instead of calling onboarding done.'
+                ]
+            },
+            {
+                id: 'optional_sources',
+                title: 'Optional source setup',
+                questions: [
+                    'Only after the first demo, ask which mail, calendar, drive/docs, or task tools should be diagnosed.',
+                    'Use source diagnosis to fill gaps exposed by the demo, not as the starting point.',
+                    'Keep imported material under sources/ and promote only reviewed facts.'
+                ]
+            }
+        ],
+        safetyRules: [
+            'Do not ask the user to paste OAuth tokens, passwords, API keys, or refresh tokens into chat.',
+            'Use read-only collection paths where available.',
+            'Do not treat raw source diagnosis, connector readiness, or candidate JSON as onboarding completion.',
+            'Keep mail, calendar, drive, and task data under sources/ until the user approves candidates.',
+            'Prefer metadata-first import. Body excerpts require explicit user approval.',
+            'Drive collection must be folder allowlist based.',
+            'The first user-facing value explanation should use plain language before internal Brainbase terms.'
+        ],
+        nextCommands: [
+            'brainbase onboard:init',
+            'brainbase onboard:seed --name "<name>" --value "<what should not be re-explained>" --project "<current project>" --relationship "<person>|<role>|<context>"',
+            'brainbase onboard:projects --name "<project>" --goal "<goal>" --status "<status>" --role "<your role>"',
+            'brainbase onboard:demo --scenario "<real request that should now work>"',
+            'brainbase onboard:skills --target codex',
+            'brainbase onboard:routines --target codex --cwd <brainbase-checkout>',
+            'brainbase onboard:install --target codex --dry-run',
+            'brainbase doctor',
+            'brainbase onboard:diagnose-sources --email gmail --calendar google-calendar --drive google-drive --drive-folder "<folder-id>" --tasks notion'
+        ],
+        completionCheck: [
+            'Personal OS directory exists.',
+            'The approved self, work, and person context are saved locally.',
+            'brainbase onboard:demo returns a try-this prompt, sample result, and useful answer for the selected real request.',
+            'The user can see what they did not have to explain again.',
+            'The completion report lists public skills, ohayo/oyasumi/retro routines, real MCP config merge, source allowlists, and MCP get_context/search verification as unfinished operationalization work.',
+            'The selected MCP client has a Brainbase config snippet merged into its real config after user approval.',
+            'Source diagnosis is optional follow-up work, but source allowlist/import/candidate review must be explicitly completed or deferred.'
+        ]
+    };
+}
+export function buildValueDemo(input) {
+    const scenario = input.scenario?.trim() || 'Draft the first message or working note that should use my saved Brainbase context.';
+    const seeded = seededAreas(input.os);
+    const missing = Object.entries(seeded)
+        .filter(([, value]) => !value)
+        .map(([key]) => key);
+    const self = selfContext(input.os);
+    const work = workContext(input.os);
+    const relationships = input.os.relationships.relationships.map((relationship) => ({
+        person: relationship.person,
+        role: relationship.role,
+        context: relationship.context
+    }));
+    const decisions = input.os.decisions.map((decision) => ({
+        title: decision.title,
+        decision: decision.decision
+    }));
+    const selectedRelationship = selectRelationship(input.os.relationships.relationships, scenario);
+    const ready = missing.length === 0;
+    const sampleResult = ready
+        ? buildReadySampleResult({ scenario, self, work, selectedRelationship, decisions })
+        : buildMissingDemoAnswer(missing);
+    const valueExplanation = ready
+        ? buildValueExplanation({ self, work, selectedRelationship, decisions })
+        : `まだ最初の価値を見せるための最小メモが足りません: ${missing.map(missingLabel).join(', ')}。`;
+    const operationalization = buildOperationalizationPlan({
+        dataDir: input.os.dataDir,
+        firstValueReady: ready
+    });
+    return {
+        goal: 'Show one useful answer from the context the user just saved before any setup follow-up.',
+        ready,
+        missing,
+        scenario,
+        tryPrompt: scenario,
+        contextUsed: {
+            ownerName: input.os.graph.owner?.name,
+            self,
+            work,
+            relationships,
+            selectedRelationship: selectedRelationship ? {
+                person: selectedRelationship.person,
+                role: selectedRelationship.role,
+                context: selectedRelationship.context
+            } : undefined,
+            decisions
+        },
+        answer: sampleResult,
+        sampleResult,
+        valueExplanation,
+        operationalization,
+        nextStep: ready
+            ? 'Do not stop here. Use the operationalization checklist below to install skills, register routines with confirmation, merge MCP config, decide source allowlists, and verify MCP get_context/search.'
+            : `First save the minimum missing memo: ${missing.map(missingLabel).join(', ')}.`,
+        completionSignal: ready ? 'first_value_demo_ready' : 'needs_seed'
+    };
+}
+export function buildSourceDiagnosis(input) {
+    const recommendationSet = buildConnectorRecommendations(input);
+    const diagnostics = recommendationSet.recommendations.map((recommendation) => diagnoseRecommendation(recommendation, input));
+    return {
+        goal: 'Diagnose local source collection readiness before any raw material or candidates are promoted into canonical Brainbase SSOT.',
+        diagnostics,
+        nextCommands: [
+            'brainbase onboard:candidates --write --name "<name>" --project "<current project>"',
+            'brainbase onboard:projects --name "<approved project>" --goal "<approved goal>"',
+            'brainbase doctor',
+            'brainbase onboard:seed --name "<name>" --value "<approved value>" --project "<approved project>"'
+        ],
+        safetyRules: [
+            'Do not paste OAuth tokens, passwords, API keys, or refresh tokens into chat.',
+            'Use metadata-first source collection before body text or document excerpts.',
+            'Keep provider output under sources/ and extracted facts under candidates/.',
+            'Promote only reviewed candidate facts into canonical SSOT.',
+            'Drive collection must use explicit folder allowlists.'
+        ]
+    };
+}
+export function buildCandidateDrafts(input) {
+    const now = input.now ?? new Date().toISOString();
+    const candidates = [];
+    if (input.name) {
+        candidates.push(candidate('self', { name: input.name }, now));
+    }
+    for (const value of input.values ?? []) {
+        candidates.push(candidate('value', { text: value, tags: ['onboarding'] }, now));
+    }
+    for (const project of input.projects ?? []) {
+        candidates.push(candidate('project', { name: project, summary: 'Approved during Brainbase agent onboarding.' }, now));
+    }
+    for (const principle of input.decisionPrinciples ?? []) {
+        candidates.push(candidate('decision', {
+            title: 'Agent onboarding decision principle',
+            decision: principle,
+            tags: ['principle', 'onboarding']
+        }, now));
+    }
+    for (const encoded of input.relationships ?? []) {
+        const [person, role, context] = encoded.split('|').map((part) => part.trim());
+        if (!person || !context) {
+            throw new Error('relationship must be "person|role|context" or "person||context"');
+        }
+        candidates.push(candidate('relationship', { person, role: role || undefined, context }, now));
+    }
+    return {
+        goal: 'Review candidate facts before promoting them into canonical Brainbase SSOT.',
+        canonicalWrites: false,
+        candidatePath: `${input.dataDir}/candidates/onboarding-candidates-${fileSafeTimestamp(now)}.json`,
+        candidates,
+        safetyRules: [
+            'Candidates are not canonical memory.',
+            'Do not promote raw source material without user review.',
+            'Only approved facts should be copied into graph.json, personal-kg.jsonl, relationships.json, or decisions.jsonl.'
+        ],
+        nextCommands: [
+            'Review the candidate file with the user.',
+            'Promote approved self/work/relationship facts with brainbase onboard:seed.',
+            'Run brainbase doctor after promotion.'
+        ]
+    };
+}
+export function buildLocalOnboardingPlan(input) {
+    const profile = input.profile || 'google-workspace-local';
+    if (profile !== 'google-workspace-local') {
+        throw new Error('profile must be google-workspace-local');
+    }
+    const host = input.host || 'local-machine';
+    const email = normalizeInput(input.email || 'google-workspace');
+    const calendar = normalizeInput(input.calendar || 'google-calendar');
+    const drive = normalizeInput(input.drive || 'google-drive');
+    const tasks = normalizeInput(input.tasks || 'scattered-calendar-notes');
+    const secondaryEmails = (input.secondaryEmails ?? []).map(normalizeInput).filter((value) => !isNone(value));
+    const driveFolders = input.driveFolders ?? [];
+    const localFolders = input.localFolders ?? [];
+    const inactiveTaskTools = (input.inactiveTaskTools ?? []).map(normalizeInput).filter((value) => !isNone(value));
+    const workspaceAccount = accountPlaceholder(email, 'google-workspace-account');
+    const secondaryAccounts = secondaryEmails.map((value, index) => accountPlaceholder(value, index === 0 ? 'secondary-gmail-account' : `secondary-email-${index + 1}`));
+    const sources = [
+        {
+            area: 'email',
+            input: [email, ...secondaryEmails].join(', '),
+            collector: 'gog gmail',
+            importMode: 'metadata-first',
+            sourcePath: 'sources/gmail/threads.jsonl',
+            accounts: [workspaceAccount, ...secondaryAccounts],
+            allowlists: [],
+            requiredUserInput: ['Workspace mail account', ...(secondaryAccounts.length > 0 ? ['Secondary Gmail account authorization'] : [])],
+            notes: [
+                'Start with thread metadata, participants, subjects, dates, labels, URLs, and snippets.',
+                'Body excerpts require explicit user approval.'
+            ]
+        },
+        {
+            area: 'calendar',
+            input: calendar,
+            collector: 'gog calendar',
+            importMode: 'metadata-first',
+            sourcePath: 'sources/calendar/events.jsonl',
+            accounts: [workspaceAccount],
+            allowlists: ['primary', '<additional-allowed-calendar-id>'],
+            requiredUserInput: ['Date range', 'Private calendar exclusion decision'],
+            notes: [
+                'Use Google Calendar as both schedule context and one source of scattered task candidates.',
+                'Descriptions and private event details are opt-in.'
+            ]
+        },
+        {
+            area: 'drive',
+            input: drive,
+            collector: 'gog drive',
+            importMode: 'metadata-first',
+            sourcePath: 'sources/drive/files.jsonl',
+            accounts: [workspaceAccount],
+            allowlists: driveFolders,
+            requiredUserInput: driveFolders.length === 0 ? ['At least one allowed Google Drive folder id'] : [],
+            notes: [
+                'List metadata for explicitly allowed Drive folders only.',
+                'Do not scan the whole Drive.',
+                'Downloads are selected-file only after review.'
+            ]
+        },
+        {
+            area: 'local_files',
+            input: localFolders.length > 0 ? localFolders.join(', ') : 'none',
+            collector: 'manual local metadata index',
+            importMode: 'manual',
+            sourcePath: 'sources/drive/local-files.jsonl',
+            accounts: [],
+            allowlists: localFolders,
+            requiredUserInput: localFolders.length === 0 ? ['At least one allowed local folder for notes or work files'] : [],
+            notes: [
+                'Use explicit local folder allowlists only.',
+                'Do not scan the full home directory.',
+                'Local notes are candidate extraction input until reviewed.'
+            ]
+        },
+        {
+            area: 'tasks',
+            input: tasks,
+            collector: 'calendar-and-notes-candidates',
+            importMode: 'manual',
+            sourcePath: 'sources/tasks/tasks.jsonl',
+            accounts: [workspaceAccount],
+            allowlists: ['calendar events', ...localFolders],
+            requiredUserInput: localFolders.length === 0 ? ['Allowed local notes folder if notes should be included'] : [],
+            notes: [
+                'Treat Google Calendar entries and local notes as task candidate inputs.',
+                'Do not require inactive tools as connectors.',
+                ...(inactiveTaskTools.length > 0 ? [`Inactive task tools: ${inactiveTaskTools.join(', ')}`] : []),
+                'Promote only reviewed tasks, relationships, decisions, and personal KG facts.'
+            ]
+        }
+    ];
+    const driveFolderArg = driveFolders.length > 0
+        ? driveFolders.map((folder) => `--drive-folder ${quoteShell(folder)}`).join(' ')
+        : '--drive-folder "<allowed-google-drive-folder-id>"';
+    return {
+        goal: 'Turn a Google Workspace local onboarding interview into a safe Brainbase MCP setup plan.',
+        profile,
+        canonicalWrites: false,
+        host: {
+            input: host,
+            role: 'local Brainbase MCP runtime host reachable by the owner over SSH',
+            boundary: 'This is not a hosted backend, server operations handoff, Lightsail sync, bb.unson.jp sync, or Infisical-managed deployment.'
+        },
+        sources,
+        setupSteps: [
+            {
+                id: 'runtime-host',
+                title: 'Prepare the local runtime host',
+                commands: [
+                    'ssh <mac-mini-host>',
+                    'git clone https://github.com/Unson-LLC/brainbase.git',
+                    'cd brainbase && npm install && npm run build'
+                ],
+                notes: [
+                    'Run Brainbase MCP on the owner-controlled Mac mini or local machine.',
+                    'Keep the Personal OS under ~/.brainbase/personal-os/.'
+                ]
+            },
+            {
+                id: 'google-workspace-readonly',
+                title: 'Authorize Google Workspace read-only collectors',
+                commands: [
+                    `gog auth add ${workspaceAccount} --services gmail,calendar,drive`,
+                    ...secondaryAccounts.map((account) => `gog auth add ${account} --services gmail`),
+                    `gog gmail search "newer_than:30d" --account ${workspaceAccount} --json`,
+                    `gog calendar events primary --account ${workspaceAccount} --from <from-date> --to <to-date> --json`,
+                    ...(driveFolders.length > 0
+                        ? driveFolders.map((folder) => `gog drive ls --parent ${folder} --account ${workspaceAccount} --json`)
+                        : [`gog drive ls --parent <allowed-google-drive-folder-id> --account ${workspaceAccount} --json`])
+                ],
+                notes: [
+                    'Use metadata-first collection.',
+                    'Do not paste OAuth credentials or tokens into chat.'
+                ]
+            },
+            {
+                id: 'candidate-extraction',
+                title: 'Register projects and draft candidates before canonical promotion',
+                commands: [
+                    'brainbase onboard:projects --name "<project>" --goal "<goal>" --status "<status>" --role "<your role>"',
+                    'brainbase onboard:candidates --write --name "<name>" --project "<current project>"',
+                    'brainbase doctor'
+                ],
+                notes: [
+                    'Review Calendar and local note task candidates with the user.',
+                    'Use onboard:seed only after approval.'
+                ]
+            }
+        ],
+        safetyRules: [
+            'No canonical SSOT writes happen during planning.',
+            'Do not paste OAuth tokens, passwords, API keys, or refresh tokens into chat.',
+            'Google source collection is metadata-first and read-only in the first pass.',
+            'Drive and local file collection are allowlist-first.',
+            'Abandoned or inactive task tools are context, not required connectors.',
+            'Hosted backend, Infisical, Unson API, Lightsail, and bb.unson.jp sync are out of scope for v1.'
+        ],
+        nextCommands: [
+            `brainbase onboard:diagnose-sources --email ${quoteShell(email)} --calendar ${quoteShell(calendar)} --drive ${quoteShell(drive)} ${driveFolderArg} --tasks ${quoteShell(tasks)}`,
+            'brainbase onboard:projects --name "<project>" --goal "<goal>" --status "<status>" --role "<your role>"',
+            'brainbase onboard:candidates --write --name "<name>" --project "<current project>"',
+            'brainbase onboard:install --target codex --dry-run',
+            'brainbase doctor'
+        ]
+    };
+}
+export function buildConnectorRecommendations(input) {
+    const recommendations = [
+        recommendEmail(input.email),
+        recommendCalendar(input.calendar),
+        recommendDrive(input.drive),
+        recommendTasks(input.tasks)
+    ];
+    return {
+        goal: 'Choose a local, read-only source collection path before promoting reviewed candidates into Brainbase canonical SSOT.',
+        recommendations,
+        canonicalization: [
+            'Store imported source material under sources/ by provider.',
+            'Extract candidates into candidates/ before canonical writes.',
+            'Promote only user-approved people, organizations, projects, relationships, decisions, and personal KG entries.',
+            'Normal MCP tools should prefer canonical files over raw source material.'
+        ],
+        nextCommands: [
+            'brainbase onboard:init',
+            'brainbase onboard:install --target codex --dry-run',
+            'brainbase doctor'
+        ]
+    };
+}
+export function renderAgentProtocol(format) {
+    const protocol = buildAgentOnboardingProtocol();
+    if (format === 'json') {
+        return `${JSON.stringify(protocol, null, 2)}\n`;
+    }
+    return [
+        '# Brainbase Agent Onboarding Protocol',
+        '',
+        protocol.goal,
+        '',
+        '## Interview',
+        ...protocol.interviewSections.flatMap((section) => [
+            '',
+            `### ${section.title}`,
+            ...section.questions.map((question) => `- ${question}`)
+        ]),
+        '',
+        '## Safety Rules',
+        ...protocol.safetyRules.map((rule) => `- ${rule}`),
+        '',
+        '## Next Commands',
+        ...protocol.nextCommands.map((command) => `- \`${command}\``),
+        '',
+        '## Completion Check',
+        ...protocol.completionCheck.map((check) => `- ${check}`),
+        ''
+    ].join('\n');
+}
+export function renderConnectorRecommendations(input, format) {
+    const recommendationSet = buildConnectorRecommendations(input);
+    if (format === 'json') {
+        return `${JSON.stringify(recommendationSet, null, 2)}\n`;
+    }
+    return [
+        '# Brainbase Connector Recommendations',
+        '',
+        recommendationSet.goal,
+        '',
+        ...recommendationSet.recommendations.flatMap((recommendation) => [
+            `## ${labelForArea(recommendation.area)}`,
+            '',
+            `- Input: ${recommendation.input}`,
+            `- Recommendation: ${recommendation.recommendation}`,
+            `- Source path: \`${recommendation.sourcePath}\``,
+            `- Import mode: ${recommendation.importMode}`,
+            '- Setup hints:',
+            ...recommendation.setupHints.map((hint) => `  - ${hint}`),
+            '- Safety notes:',
+            ...recommendation.safetyNotes.map((note) => `  - ${note}`),
+            ''
+        ]),
+        '## Canonicalization',
+        ...recommendationSet.canonicalization.map((item) => `- ${item}`),
+        '',
+        '## Next Commands',
+        ...recommendationSet.nextCommands.map((command) => `- \`${command}\``),
+        ''
+    ].join('\n');
+}
+export function renderSourceDiagnosis(input, format) {
+    const diagnosisSet = buildSourceDiagnosis(input);
+    if (format === 'json') {
+        return `${JSON.stringify(diagnosisSet, null, 2)}\n`;
+    }
+    return [
+        '# Brainbase Source Diagnosis',
+        '',
+        diagnosisSet.goal,
+        '',
+        ...diagnosisSet.diagnostics.flatMap((diagnosis) => [
+            `## ${labelForArea(diagnosis.area)}`,
+            '',
+            `- Input: ${diagnosis.input}`,
+            `- Status: ${diagnosis.status}`,
+            `- Collector: ${diagnosis.collector ?? 'none'}`,
+            `- Source path: \`${diagnosis.sourcePath}\``,
+            `- Write target: \`${diagnosis.writeTarget}\``,
+            `- Import mode: ${diagnosis.importMode}`,
+            '- Required user input:',
+            ...(diagnosis.requiredUserInput.length === 0 ? ['  - none'] : diagnosis.requiredUserInput.map((item) => `  - ${item}`)),
+            '- Setup commands:',
+            ...(diagnosis.setupCommands.length === 0 ? ['  - none'] : diagnosis.setupCommands.map((command) => `  - \`${command}\``)),
+            '- Safety notes:',
+            ...diagnosis.safetyNotes.map((note) => `  - ${note}`),
+            ''
+        ]),
+        '## Safety Rules',
+        ...diagnosisSet.safetyRules.map((rule) => `- ${rule}`),
+        '',
+        '## Next Commands',
+        ...diagnosisSet.nextCommands.map((command) => `- \`${command}\``),
+        ''
+    ].join('\n');
+}
+export function renderValueDemo(input, format) {
+    const demo = buildValueDemo(input);
+    if (format === 'json') {
+        return `${JSON.stringify(demo, null, 2)}\n`;
+    }
+    return [
+        '# Brainbase First Value Demo',
+        '',
+        demo.goal,
+        '',
+        `- Ready: ${String(demo.ready)}`,
+        `- Completion signal: ${demo.completionSignal}`,
+        `- Missing: ${demo.missing.length === 0 ? 'none' : demo.missing.map(missingLabel).join(', ')}`,
+        '',
+        '## Try This Now',
+        demo.tryPrompt,
+        '',
+        '## Sample Result',
+        demo.sampleResult,
+        '',
+        '## What Changed',
+        demo.valueExplanation,
+        '',
+        '## Operationalization Still Pending',
+        demo.operationalization.goal,
+        '',
+        '### Completed',
+        ...demo.operationalization.completed.map((item) => `- ${item}`),
+        '',
+        '### Next Actions',
+        ...demo.operationalization.pending.map((item) => `- ${item.title}: \`${item.command}\` (${item.safety})`),
+        '',
+        '### Recommended Order',
+        ...demo.operationalization.recommendedOrder.map((item, index) => `${index + 1}. ${item}`),
+        '',
+        '## Next Step',
+        demo.nextStep,
+        ''
+    ].join('\n');
+}
+export function renderCandidateDrafts(input, format) {
+    const candidateSet = buildCandidateDrafts(input);
+    if (format === 'json') {
+        return `${JSON.stringify(candidateSet, null, 2)}\n`;
+    }
+    return [
+        '# Brainbase Onboarding Candidates',
+        '',
+        candidateSet.goal,
+        '',
+        `- Canonical writes: ${String(candidateSet.canonicalWrites)}`,
+        `- Candidate path: \`${candidateSet.candidatePath}\``,
+        '',
+        '## Candidates',
+        ...(candidateSet.candidates.length === 0
+            ? ['- none']
+            : candidateSet.candidates.map((candidate) => `- ${candidate.kind}: ${JSON.stringify(candidate.payload)}`)),
+        '',
+        '## Safety Rules',
+        ...candidateSet.safetyRules.map((rule) => `- ${rule}`),
+        '',
+        '## Next Commands',
+        ...candidateSet.nextCommands.map((command) => `- ${command}`),
+        ''
+    ].join('\n');
+}
+export function renderLocalOnboardingPlan(input, format) {
+    const plan = buildLocalOnboardingPlan(input);
+    if (format === 'json') {
+        return `${JSON.stringify(plan, null, 2)}\n`;
+    }
+    return [
+        '# Brainbase Local Onboarding Plan',
+        '',
+        plan.goal,
+        '',
+        `- Profile: ${plan.profile}`,
+        `- Canonical writes: ${String(plan.canonicalWrites)}`,
+        '',
+        '## Runtime Host',
+        `- Input: ${plan.host.input}`,
+        `- Role: ${plan.host.role}`,
+        `- Boundary: ${plan.host.boundary}`,
+        '',
+        '## Sources',
+        ...plan.sources.flatMap((source) => [
+            '',
+            `### ${labelForPlanArea(source.area)}`,
+            `- Input: ${source.input}`,
+            `- Collector: ${source.collector}`,
+            `- Import mode: ${source.importMode}`,
+            `- Source path: \`${source.sourcePath}\``,
+            `- Accounts: ${source.accounts.length > 0 ? source.accounts.join(', ') : 'none'}`,
+            `- Allowlists: ${source.allowlists.length > 0 ? source.allowlists.join(', ') : 'none'}`,
+            '- Required user input:',
+            ...(source.requiredUserInput.length === 0 ? ['  - none'] : source.requiredUserInput.map((item) => `  - ${item}`)),
+            '- Notes:',
+            ...source.notes.map((note) => `  - ${note}`)
+        ]),
+        '',
+        '## Setup Steps',
+        ...plan.setupSteps.flatMap((step) => [
+            '',
+            `### ${step.title}`,
+            '- Commands:',
+            ...step.commands.map((command) => `  - \`${command}\``),
+            '- Notes:',
+            ...step.notes.map((note) => `  - ${note}`)
+        ]),
+        '',
+        '## Safety Rules',
+        ...plan.safetyRules.map((rule) => `- ${rule}`),
+        '',
+        '## Next Commands',
+        ...plan.nextCommands.map((command) => `- \`${command}\``),
+        ''
+    ].join('\n');
+}
+export function parseOnboardingFormat(value) {
+    if (!value || value === 'markdown') {
+        return 'markdown';
+    }
+    if (value === 'json') {
+        return 'json';
+    }
+    throw new Error('format must be markdown|json');
+}
+function diagnoseRecommendation(recommendation, input) {
+    const writeTarget = `${input.dataDir}/${recommendation.sourcePath}`;
+    if (recommendation.importMode === 'not-configured') {
+        return {
+            area: recommendation.area,
+            input: recommendation.input,
+            status: 'not_configured',
+            collector: null,
+            sourcePath: recommendation.sourcePath,
+            writeTarget,
+            importMode: recommendation.importMode,
+            requiredUserInput: [],
+            setupCommands: [],
+            safetyNotes: recommendation.safetyNotes
+        };
+    }
+    if (isGoogleDiagnosis(recommendation)) {
+        const gogCommand = input.gogCommand || 'gog';
+        const driveFolders = input.driveFolders ?? [];
+        const needsDriveFolder = recommendation.area === 'drive' && driveFolders.length === 0;
+        const status = input.gogAvailable
+            ? (needsDriveFolder ? 'needs_input' : 'ready')
+            : 'needs_setup';
+        return {
+            area: recommendation.area,
+            input: recommendation.input,
+            status,
+            collector: 'gog',
+            sourcePath: recommendation.sourcePath,
+            writeTarget,
+            importMode: 'metadata-first',
+            requiredUserInput: [
+                ...(input.gogAvailable ? [] : [`Install or configure local GoG command: ${gogCommand}`]),
+                ...(needsDriveFolder ? ['At least one allowed Google Drive folder id'] : []),
+                ...(recommendation.area === 'calendar' ? ['Date range and private-calendar exclusion decision'] : []),
+                ...(recommendation.area === 'email' ? ['Mail account and metadata/body-excerpt scope decision'] : [])
+            ],
+            setupCommands: googleSetupCommands(recommendation.area, gogCommand, writeTarget, driveFolders),
+            safetyNotes: recommendation.safetyNotes
+        };
+    }
+    return {
+        area: recommendation.area,
+        input: recommendation.input,
+        status: recommendation.importMode === 'manual' ? 'needs_input' : 'needs_setup',
+        collector: collectorFor(recommendation),
+        sourcePath: recommendation.sourcePath,
+        writeTarget,
+        importMode: recommendation.importMode,
+        requiredUserInput: nonGoogleRequiredInput(recommendation),
+        setupCommands: nonGoogleSetupCommands(recommendation, writeTarget),
+        safetyNotes: recommendation.safetyNotes
+    };
+}
+function seededAreas(os) {
+    return {
+        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
+    };
+}
+function selfContext(os) {
+    return [
+        ...(os.graph.owner?.name ? [`Owner: ${os.graph.owner.name}`] : []),
+        ...(os.graph.owner?.summary ? [os.graph.owner.summary] : []),
+        ...os.personalKg
+            .filter((entry) => entry.type === 'self' || entry.type === 'value' || entry.type === 'judgment')
+            .map((entry) => entry.text)
+    ];
+}
+function workContext(os) {
+    return [
+        ...os.graph.entities
+            .filter((entity) => entity.type === 'project')
+            .map((entity) => entity.summary ? `${entity.name}: ${entity.summary}` : entity.name),
+        ...os.personalKg
+            .filter((entry) => entry.type === 'work' || entry.type === 'experience')
+            .map((entry) => entry.text)
+    ];
+}
+function selectRelationship(relationships, scenario) {
+    const normalizedScenario = normalizeForMatch(scenario);
+    return relationships.find((relationship) => relationshipTerms(relationship.person)
+        .some((term) => normalizedScenario.includes(normalizeForMatch(term))))
+        ?? relationships[0];
+}
+function relationshipTerms(name) {
+    const compact = name.replace(/\s+/g, '');
+    const terms = new Set([
+        name,
+        compact,
+        ...name.split(/[\s,|/()]+/).filter(Boolean)
+    ]);
+    if (compact.length >= 2) {
+        terms.add(compact.slice(0, 2));
+    }
+    return [...terms].filter((term) => term.length >= 2);
+}
+function normalizeForMatch(value) {
+    return value.toLowerCase().replace(/\s+/g, '');
+}
+function buildReadySampleResult(input) {
+    const projectLine = input.work[0] ?? '保存済みの仕事メモ';
+    const ownerLine = input.self[0] ?? 'あなたの進め方';
+    const relationshipLine = input.selectedRelationship
+        ? `${input.selectedRelationship.person}${input.selectedRelationship.role ? `（${input.selectedRelationship.role}）` : ''}には、${input.selectedRelationship.context}を前提に相談します。`
+        : '特定の相談相手が未指定なので、まず保存済みの仕事メモから次の一手を整理します。';
+    const decisionLine = input.decisions[0]
+        ? `判断基準: ${input.decisions[0].decision}`
+        : '追加の判断基準はまだないので、次に動ける形へ絞ります。';
+    return [
+        `「${input.scenario}」への回答例:`,
+        '',
+        `次に進める作業は、${projectLine}を前提に一つのメモへ整理することです。`,
+        `進め方は、${ownerLine}を崩さず、説明を足しすぎない形にします。`,
+        relationshipLine,
+        decisionLine,
+        '',
+        'そのまま送れる最初のアウトプット:',
+        input.selectedRelationship
+            ? `${input.selectedRelationship.person}さんに確認したい論点を、背景説明ではなく「次に判断したいこと」と「相談したいこと」に分けて出します。`
+            : '保存済みの仕事メモから、今日進める作業と追加で確認したい一点だけを出します。'
+    ].join('\n');
+}
+function buildValueExplanation(input) {
+    const remembered = [];
+    if (input.self[0])
+        remembered.push('あなたの前提');
+    if (input.work[0])
+        remembered.push('今の仕事');
+    if (input.selectedRelationship)
+        remembered.push(`${input.selectedRelationship.person}さんの文脈`);
+    if (input.decisions[0])
+        remembered.push('判断基準');
+    return remembered.length === 0
+        ? 'まだ十分なメモがないため、説明し直しを減らせていません。'
+        : `${remembered.join('、')}をもう一度説明しなくても、回答がそこから始まります。`;
+}
+function buildMissingDemoAnswer(missing) {
+    return [
+        'まだ最初の価値体験はできません。',
+        `足りない最小メモ: ${missing.map(missingLabel).join(', ')}。`,
+        'まず、あなたが毎回説明したくないことを一つだけ保存してから、同じプロンプトをもう一度試します。'
+    ].join('\n');
+}
+function missingLabel(value) {
+    if (value === 'self')
+        return 'あなた自身の前提';
+    if (value === 'work')
+        return '今の仕事';
+    if (value === 'relationships')
+        return '相談相手や関係者';
+    return value;
+}
+function isGoogleDiagnosis(recommendation) {
+    return recommendation.importMode === 'metadata-first'
+        && (recommendation.recommendation.includes('GoG') || recommendation.recommendation.includes('Google'));
+}
+function googleSetupCommands(area, gogCommand, writeTarget, driveFolders) {
+    if (area === 'email') {
+        return [
+            `${gogCommand} gmail auth --readonly`,
+            `${gogCommand} gmail threads --metadata --out ${writeTarget}`
+        ];
+    }
+    if (area === 'calendar') {
+        return [
+            `${gogCommand} calendar auth --readonly`,
+            `${gogCommand} calendar events --metadata --out ${writeTarget}`
+        ];
+    }
+    if (area === 'drive') {
+        const folder = driveFolders[0] ?? '<allowed-folder-id>';
+        return [
+            `${gogCommand} drive auth --readonly`,
+            `${gogCommand} drive ls ${folder} --json --out ${writeTarget}`,
+            `${gogCommand} drive download <file-id> --out <approved-output-path>`
+        ];
+    }
+    return [];
+}
+function collectorFor(recommendation) {
+    if (recommendation.area === 'tasks') {
+        if (matches(recommendation.input, ['notion']))
+            return 'notion-mcp-or-export';
+        if (matches(recommendation.input, ['linear']))
+            return 'linear-mcp-or-export';
+        if (matches(recommendation.input, ['github', 'github issues', 'github-issues', 'issues']))
+            return 'github-connector-or-export';
+        if (matches(recommendation.input, ['nocodb']))
+            return 'nocodb-mcp-or-export';
+    }
+    return recommendation.importMode === 'manual' ? 'manual-export' : 'external-export';
+}
+function nonGoogleRequiredInput(recommendation) {
+    if (recommendation.importMode === 'manual') {
+        return ['Explicit local file, folder, CSV, or JSONL export path'];
+    }
+    if (recommendation.area === 'tasks') {
+        return ['Workspace/project/database allowlist', 'Read-only export or connector path'];
+    }
+    return ['Read-only export path', 'Allowed account or workspace'];
+}
+function nonGoogleSetupCommands(recommendation, writeTarget) {
+    if (matches(recommendation.input, ['none', 'no', 'なし'])) {
+        return [];
+    }
+    if (matches(recommendation.input, ['csv', 'spreadsheet', 'excel', 'manual'])) {
+        return [`Normalize the approved export into ${writeTarget}`];
+    }
+    return [`Export or collect read-only data, then normalize JSONL into ${writeTarget}`];
+}
+function candidate(kind, payload, createdAt) {
+    return {
+        id: `candidate-${kind}-${hash(`${kind}:${JSON.stringify(payload)}`)}`,
+        kind,
+        payload,
+        source: 'agent-interview',
+        promoted: false,
+        createdAt
+    };
+}
+function fileSafeTimestamp(value) {
+    return value.replace(/[^0-9A-Za-z-]/g, '-');
+}
+function hash(value) {
+    let hashValue = 0;
+    for (const char of value) {
+        hashValue = ((hashValue << 5) - hashValue + char.charCodeAt(0)) | 0;
+    }
+    return Math.abs(hashValue).toString(36);
+}
+function recommendEmail(value) {
+    const input = normalizeInput(value);
+    if (isNone(input))
+        return notConfigured('email', input, 'sources/gmail/threads.jsonl');
+    if (matches(input, ['gmail', 'google', 'google mail', 'google workspace', 'google-workspace', 'gws', 'workspace'])) {
+        return {
+            area: 'email',
+            input,
+            recommendation: 'Use local GoG Gmail collection when available.',
+            sourcePath: 'sources/gmail/threads.jsonl',
+            importMode: 'metadata-first',
+            setupHints: [
+                'Run GoG auth for Gmail with a read-only scope.',
+                'Start from thread metadata, participants, subject, dates, labels, URLs, and snippets.',
+                'Collect body excerpts only after the user approves that scope.'
+            ],
+            safetyNotes: commonSafetyNotes()
+        };
+    }
+    if (matches(input, ['outlook', 'microsoft', 'microsoft 365', 'office 365', 'exchange'])) {
+        return exportFirst('email', input, 'sources/gmail/threads.jsonl', 'Use Microsoft Graph or mailbox export as a future connector path.');
+    }
+    if (matches(input, ['apple', 'apple mail', 'mail.app'])) {
+        return exportFirst('email', input, 'sources/gmail/threads.jsonl', 'Use Apple Mail export or mbox import as a future connector path.');
+    }
+    return manual('email', input, 'sources/gmail/threads.jsonl');
+}
+function recommendCalendar(value) {
+    const input = normalizeInput(value);
+    if (isNone(input))
+        return notConfigured('calendar', input, 'sources/calendar/events.jsonl');
+    if (matches(input, ['google', 'google-calendar', 'google calendar', 'gcal', 'google workspace', 'google-workspace', 'gws', 'workspace'])) {
+        return {
+            area: 'calendar',
+            input,
+            recommendation: 'Use local GoG Google Calendar collection when available.',
+            sourcePath: 'sources/calendar/events.jsonl',
+            importMode: 'metadata-first',
+            setupHints: [
+                'Run GoG auth for calendar with a read-only scope.',
+                'Collect event id, title, start/end, organizer, attendees, recurrence, URL, and selected metadata.',
+                'Treat private calendars and descriptions as opt-in.'
+            ],
+            safetyNotes: commonSafetyNotes()
+        };
+    }
+    if (matches(input, ['outlook', 'microsoft', 'microsoft 365', 'office 365', 'exchange'])) {
+        return exportFirst('calendar', input, 'sources/calendar/events.jsonl', 'Use Microsoft Graph or calendar export as a future connector path.');
+    }
+    if (matches(input, ['apple', 'apple calendar', 'ical', 'icloud'])) {
+        return exportFirst('calendar', input, 'sources/calendar/events.jsonl', 'Use iCalendar export as a future connector path.');
+    }
+    return manual('calendar', input, 'sources/calendar/events.jsonl');
+}
+function recommendDrive(value) {
+    const input = normalizeInput(value);
+    if (isNone(input))
+        return notConfigured('drive', input, 'sources/drive/files.jsonl');
+    if (matches(input, ['google', 'google-drive', 'google drive', 'drive', 'google-docs', 'google docs', 'docs', 'google workspace', 'google-workspace', 'gws', 'workspace'])) {
+        return {
+            area: 'drive',
+            input,
+            recommendation: 'Use local GoG Drive collection with an explicit folder allowlist.',
+            sourcePath: 'sources/drive/files.jsonl',
+            importMode: 'metadata-first',
+            setupHints: [
+                'Run GoG auth for Drive with a read-only scope.',
+                'Ask the user for allowed folder ids before collection.',
+                'Use metadata first: file id, title, mime type, owner, modified time, folder path, URL.',
+                'If downloading is approved, use GoG Drive download with --out for selected files only.'
+            ],
+            safetyNotes: [
+                ...commonSafetyNotes(),
+                'Do not scan the whole Drive by default.',
+                'Exclude contracts, medical, finance, and private folders unless explicitly approved.'
+            ]
+        };
+    }
+    if (matches(input, ['onedrive', 'one drive', 'sharepoint', 'microsoft'])) {
+        return exportFirst('drive', input, 'sources/drive/files.jsonl', 'Use Microsoft Graph or selective export as a future connector path.');
+    }
+    if (matches(input, ['dropbox'])) {
+        return exportFirst('drive', input, 'sources/drive/files.jsonl', 'Use Dropbox export or API collection as a future connector path.');
+    }
+    if (matches(input, ['local', 'folder', 'local folder', 'filesystem'])) {
+        return manual('drive', input, 'sources/drive/files.jsonl', 'Use an explicit local folder allowlist.');
+    }
+    return manual('drive', input, 'sources/drive/files.jsonl');
+}
+function recommendTasks(value) {
+    const input = normalizeInput(value);
+    if (isNone(input))
+        return notConfigured('tasks', input, 'sources/tasks/tasks.jsonl');
+    if (matches(input, ['notion'])) {
+        return exportFirst('tasks', input, 'sources/tasks/tasks.jsonl', 'Use Notion MCP, Notion API, or a database export.');
+    }
+    if (matches(input, ['todoist'])) {
+        return exportFirst('tasks', input, 'sources/tasks/tasks.jsonl', 'Use Todoist API or export.');
+    }
+    if (matches(input, ['linear'])) {
+        return exportFirst('tasks', input, 'sources/tasks/tasks.jsonl', 'Use Linear MCP or issue export.');
+    }
+    if (matches(input, ['github', 'github issues', 'issues'])) {
+        return exportFirst('tasks', input, 'sources/tasks/tasks.jsonl', 'Use GitHub Issues through the GitHub connector or export.');
+    }
+    if (matches(input, ['nocodb'])) {
+        return exportFirst('tasks', input, 'sources/tasks/tasks.jsonl', 'Use NocoDB MCP/API or table export.');
+    }
+    if (matches(input, ['csv', 'spreadsheet', 'excel', 'manual'])) {
+        return manual('tasks', input, 'sources/tasks/tasks.jsonl', 'Use CSV or JSONL import from an explicit file.');
+    }
+    if (matches(input, ['scattered-calendar-notes', 'calendar-notes', 'calendar and notes', 'calendar', 'notes', 'memo', 'memos'])) {
+        return manual('tasks', input, 'sources/tasks/tasks.jsonl', 'Use Google Calendar entries and explicit local notes as candidate task inputs.');
+    }
+    return manual('tasks', input, 'sources/tasks/tasks.jsonl');
+}
+function exportFirst(area, input, sourcePath, recommendation) {
+    return {
+        area,
+        input,
+        recommendation,
+        sourcePath,
+        importMode: 'export-first',
+        setupHints: [
+            'Prefer an official read-only API or user-generated export.',
+            'Normalize into JSONL under the source path before extracting candidates.'
+        ],
+        safetyNotes: commonSafetyNotes()
+    };
+}
+function manual(area, input, sourcePath, recommendation = 'Use a manual export or local JSONL file until a connector is implemented.') {
+    return {
+        area,
+        input,
+        recommendation,
+        sourcePath,
+        importMode: 'manual',
+        setupHints: [
+            'Ask the user for an explicit export file or folder.',
+            'Normalize into JSONL under the source path before extracting candidates.'
+        ],
+        safetyNotes: commonSafetyNotes()
+    };
+}
+function notConfigured(area, input, sourcePath) {
+    return {
+        area,
+        input,
+        recommendation: 'No connector configured for this area.',
+        sourcePath,
+        importMode: 'not-configured',
+        setupHints: [
+            'Skip this area during onboarding unless the user later selects a tool.'
+        ],
+        safetyNotes: commonSafetyNotes()
+    };
+}
+function commonSafetyNotes() {
+    return [
+        'Keep raw source material under sources/ until reviewed.',
+        'Do not paste secrets or OAuth tokens into chat.',
+        'Promote only approved candidates into canonical SSOT.'
+    ];
+}
+function normalizeInput(value) {
+    return value?.trim().toLowerCase() || 'none';
+}
+function accountPlaceholder(input, fallback) {
+    if (input.includes('@')) {
+        return input;
+    }
+    if (matches(input, ['gmail', 'google mail'])) {
+        return '<gmail-account>';
+    }
+    if (matches(input, ['google-workspace', 'google workspace', 'gws', 'workspace'])) {
+        return `<${fallback}>`;
+    }
+    return `<${fallback}>`;
+}
+function quoteShell(value) {
+    if (/^[A-Za-z0-9._:@/-]+$/.test(value)) {
+        return value;
+    }
+    return JSON.stringify(value);
+}
+function matches(input, aliases) {
+    return aliases.includes(input);
+}
+function isNone(input) {
+    return input === 'none' || input === 'no' || input === 'なし';
+}
+function labelForArea(area) {
+    if (area === 'email')
+        return 'Email';
+    if (area === 'calendar')
+        return 'Calendar';
+    if (area === 'drive')
+        return 'Drive and Docs';
+    return 'Tasks';
+}
+function labelForPlanArea(area) {
+    if (area === 'local_files')
+        return 'Local Files';
+    return labelForArea(area);
+}