phaedo-mcp 0.1.0

package/receipts.js

@@ -0,0 +1,211 @@
+// Phaedo §10.6 — consultation RECEIPTS (build brief M4).
+//
+// An encrypted, append-only, vault-held record of every resolved consultation —
+// the subject's audit trail ("which agent asked what, and what did my oracle
+// say?") and the data layer the delegation gradient (M5 agreement tracking)
+// reads. Receipts NEVER leave the device; Phaedo holds nothing.
+//
+// Crypto: the same AES-256-GCM envelope machinery as everything else (no new
+// crypto). The receipts key is derived from the server's stored root key via
+// HKDF-SHA-256 with the DISTINCT domain-separation context
+// `phaedo:receipts:enc:v0.1` (mirrors §8.4's seed_key pattern), so the receipt
+// store and the fingerprint cache are independent ciphertexts under one root.
+//
+// Semantics (§10.6): APPEND-ONLY. A receipt is never edited after write except
+// its `user_action` field (null at write; later approved|rejected|modified|
+// unknown when override data exists), and never deleted individually — only
+// cap-evicted (oldest first) or destroyed with the account. This module exposes
+// no delete-one API on purpose.
+//
+// Write path: the MCP tool layer calls appendReceipt AFTER resolution — the
+// resolver core stays pure (no I/O). Receipt-write failure must never break the
+// consultation itself (the server warns on stderr and still answers).
+
+import { mkdir, readFile, writeFile, chmod } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { Phaedo, b64uEnc, b64uDec } from './lib/phaedo-crypto.js';
+import { getOrCreateCacheKey, defaultStateDir } from './cache.js';
+
+const { Envelope } = Phaedo;
+
+export const RECEIPTS_CONTEXT = 'phaedo:receipts:enc:v0.1';
+export const USER_ACTIONS = ['approved', 'rejected', 'modified', 'unknown'];
+export const DEFAULT_CAP = 5000;
+
+export function receiptsCapFromEnv(env = process.env) {
+  const n = Number(env.PHAEDO_RECEIPTS_CAP);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : DEFAULT_CAP;
+}
+
+// Derive the receipts key from the stored root key under the receipts context.
+// Distinct info string → distinct key: the receipt store is NOT decryptable with
+// the cache key (or vice versa), so a leak of one artifact exposes nothing else.
+async function deriveReceiptsKey(stateDir) {
+  const root = await getOrCreateCacheKey(stateDir);
+  const ikm = await crypto.subtle.importKey('raw', root, 'HKDF', false, ['deriveBits']);
+  const bits = await crypto.subtle.deriveBits(
+    { name: 'HKDF', hash: 'SHA-256', salt: new Uint8Array(0), info: new TextEncoder().encode(RECEIPTS_CONTEXT) },
+    ikm,
+    32 * 8,
+  );
+  return new Uint8Array(bits);
+}
+
+const storePath = (stateDir) => join(stateDir, 'receipts.enc');
+
+async function readStore(stateDir) {
+  const p = storePath(stateDir);
+  if (!existsSync(p)) return { receipts_version: '0.1', receipts: [] };
+  // Unlike the cache (recoverable from the phone), receipts are the ONLY copy —
+  // a corrupt/undecryptable store throws rather than silently starting over.
+  const key = await deriveReceiptsKey(stateDir);
+  const { envelope } = JSON.parse(await readFile(p, 'utf8'));
+  const plaintext = await Envelope.unwrap(envelope, key);
+  const store = JSON.parse(new TextDecoder().decode(plaintext));
+  plaintext.fill(0);
+  return store;
+}
+
+async function writeStore(stateDir, store, now) {
+  await mkdir(stateDir, { recursive: true, mode: 0o700 });
+  const key = await deriveReceiptsKey(stateDir);
+  const plaintext = new TextEncoder().encode(JSON.stringify(store));
+  const envelope = await Envelope.wrap(plaintext, key, {
+    artifact_kind: 'consultation_receipts',
+    count: store.receipts.length,
+    created_at: new Date(now).toISOString(),
+  });
+  plaintext.fill(0);
+  const p = storePath(stateDir);
+  await writeFile(p, JSON.stringify({ envelope }), { mode: 0o600 });
+  await chmod(p, 0o600);
+}
+
+// Build the §10.6 receipt object from a resolved consultation. Pure. Captures the
+// request descriptor and the response SIGNAL FIELDS only — never layer content,
+// never the projection (§10.4 holds inside the vault too). `via` records which
+// tool resolved it (phaedo_consult | phaedo_check_authorization) so M5 can weigh
+// full consultations and pre-flight matches separately.
+export function buildReceipt({ via, agentId, request, response, now = Date.now() }) {
+  const ad = (request && typeof request.action_descriptor === 'object' && request.action_descriptor) || {};
+  return {
+    receipt_id: crypto.randomUUID(),
+    created_at: new Date(now).toISOString(),
+    via: via || 'phaedo_consult',
+    agent_id: typeof agentId === 'string' ? agentId : null,
+    request: {
+      consultation_type: request?.consultation_type || 'action_approval',
+      action_descriptor: {
+        domain: typeof ad.domain === 'string' ? ad.domain : null,
+        reversible: typeof ad.reversible === 'boolean' ? ad.reversible : null,
+        magnitude: typeof ad.magnitude === 'string' ? ad.magnitude : null,
+        amount: typeof ad.amount === 'number' ? ad.amount : null,
+        summary: typeof ad.summary === 'string' ? ad.summary.slice(0, 500) : null,
+      },
+    },
+    response: {
+      signal: response?.signal ?? null,
+      confidence: typeof response?.confidence === 'number' ? response.confidence : null,
+      deference_level: response?.deference_level ?? null,
+    },
+    user_action: null,
+  };
+}
+
+// Append one receipt; evict oldest beyond the cap. Returns the stored receipt.
+export async function appendReceipt(stateDir, receipt, { cap = DEFAULT_CAP, now = Date.now() } = {}) {
+  const store = await readStore(stateDir);
+  store.receipts.push(receipt);
+  if (store.receipts.length > cap) store.receipts.splice(0, store.receipts.length - cap);
+  await writeStore(stateDir, store, now);
+  return receipt;
+}
+
+// The ONE permitted mutation (§10.6): set user_action on an existing receipt.
+// Every other field is immutable after write. Returns true if found.
+export async function updateUserAction(stateDir, receiptId, action, { now = Date.now() } = {}) {
+  if (!USER_ACTIONS.includes(action)) {
+    throw new Error(`user_action must be one of: ${USER_ACTIONS.join(', ')}`);
+  }
+  const store = await readStore(stateDir);
+  const r = store.receipts.find((x) => x.receipt_id === receiptId);
+  if (!r) return false;
+  r.user_action = action;
+  await writeStore(stateDir, store, now);
+  return true;
+}
+
+// Decrypt and return all receipts (oldest first). The dev/harness read path — and
+// M5's input. Throws on a corrupt store (receipts are the only copy).
+export async function readReceipts(stateDir) {
+  return (await readStore(stateDir)).receipts;
+}
+
+// Resolve a user-friendly selector to a full receipt_id. Pure. Accepts:
+//   - 'latest' (or empty) → the most recent receipt
+//   - a full receipt_id, or any UNIQUE id PREFIX (the short id `list` prints)
+// Returns { ok, id } or { ok:false, reason } (none / ambiguous / empty store).
+export function resolveReceiptSelector(receipts, selector) {
+  const list = Array.isArray(receipts) ? receipts : [];
+  if (!list.length) return { ok: false, reason: 'no receipts yet' };
+  if (!selector || selector === 'latest') return { ok: true, id: list[list.length - 1].receipt_id };
+  const exact = list.find((r) => r.receipt_id === selector);
+  if (exact) return { ok: true, id: exact.receipt_id };
+  const hits = list.filter((r) => r.receipt_id.startsWith(selector));
+  if (hits.length === 1) return { ok: true, id: hits[0].receipt_id };
+  if (hits.length === 0) return { ok: false, reason: `no receipt matches "${selector}"` };
+  return { ok: false, reason: `"${selector}" matches ${hits.length} receipts — use more characters` };
+}
+
+// Mark a receipt's user_action — what the SUBJECT decided about an action they
+// consulted on (approved | rejected | modified | unknown). This is what makes the
+// agreement metric (agreement.js) live: until receipts carry a user_action, every
+// consultation sits in `awaiting_user_action`. Subject-authored by definition — set
+// it from what YOU did, not from whether an agent proceeded (that would measure
+// agent obedience, not how well the oracle predicts you).
+export async function markOutcome(stateDir, selector, action) {
+  if (!USER_ACTIONS.includes(action)) {
+    throw new Error(`user_action must be one of: ${USER_ACTIONS.join(', ')}`);
+  }
+  const sel = resolveReceiptSelector(await readReceipts(stateDir), selector);
+  if (!sel.ok) return { matched: false, reason: sel.reason };
+  await updateUserAction(stateDir, sel.id, action);
+  return { matched: true, receipt_id: sel.id, user_action: action };
+}
+
+// ── Dev CLI: `node receipts.js [list|mark]` — quick on-device readout/marking ──
+// All local: decrypts with the local key, nothing leaves this machine.
+//   node receipts.js list                       # list (shows a short id per line)
+//   node receipts.js mark <id|prefix|latest> <approved|rejected|modified|unknown>
+if (process.argv[1] && process.argv[1].endsWith('receipts.js')) {
+  const [cmd, a, b] = process.argv.slice(2);
+  const dir = defaultStateDir();
+  const run = async () => {
+    if (cmd === 'mark') {
+      if (!a || !b) { console.error('usage: node receipts.js mark <id|prefix|latest> <approved|rejected|modified|unknown>'); process.exit(2); }
+      const res = await markOutcome(dir, a, b);
+      if (!res.matched) { console.error(`mark: ${res.reason}`); process.exit(1); }
+      console.log(`marked ${res.receipt_id.slice(0, 8)} → user_action: ${res.user_action}`);
+      console.log('(run `npm run agreement` to see it counted)');
+      return;
+    }
+    if (cmd === 'list' || cmd === undefined) {
+      const rs = await readReceipts(dir);
+      console.log(`${rs.length} receipt(s) in ${dir}/receipts.enc`);
+      console.log(`(mark one: node receipts.js mark <id> approved|rejected|modified)\n`);
+      for (const r of rs.slice(-50)) {
+        const ad = r.request.action_descriptor;
+        console.log(
+          `${r.receipt_id.slice(0, 8)}  ${r.created_at}  ${r.via === 'phaedo_check_authorization' ? '[pre-flight]' : '[consult]  '}` +
+          ` ${r.request.consultation_type}  ${ad.domain || '-'}` +
+          `  → ${r.response.signal} (conf ${r.response.confidence}, def ${r.response.deference_level})` +
+          `  user_action: ${r.user_action ?? '—'}`
+        );
+      }
+      return;
+    }
+    console.error(`unknown command "${cmd}" — use: list | mark`); process.exit(2);
+  };
+  run().catch((e) => { console.error(`receipts: ${e.message}`); process.exit(1); });
+}

package/sample-fingerprint.json

@@ -0,0 +1,107 @@
+{
+  "phaedo_fingerprint": {
+    "fingerprint_id": "sample-0000-0000-0000-000000000000",
+    "updated_at": "2026-06-01T12:00:00.000Z",
+    "persona_strength": 0.58,
+    "layers": {
+      "surface": {
+        "label": "Communication style",
+        "responses": [
+          {
+            "label": "Response Length",
+            "question": "How long should answers be?",
+            "answer": "Thorough — go deep and cover edge cases. Length is fine when it earns its place."
+          },
+          {
+            "label": "Formatting",
+            "question": "Preferred formatting?",
+            "answer": "Inline examples first, then plain prose, then bullet lists. Numbered steps for procedures."
+          }
+        ],
+        "summary": "Prefers concise, direct answers; bottom-line first.",
+        "signals": [
+          {
+            "field": "response_length_pref",
+            "polarity": "positive",
+            "value": "thorough",
+            "confidence": 0.7,
+            "observation_count": 1,
+            "source": "questionnaire"
+          },
+          {
+            "field": "directness",
+            "polarity": "positive",
+            "value": "high",
+            "confidence": 0.62,
+            "observation_count": 3,
+            "source": "delta"
+          }
+        ]
+      },
+      "domain_and_expertise": {
+        "label": "Domain and expertise",
+        "responses": [
+          {
+            "label": "Primary Expertise",
+            "question": "What is your domain?",
+            "answer": "Operational frameworks, policy, and process for HR teams. Uses Python and SQL occasionally to wrangle data."
+          }
+        ],
+        "signals": [
+          {
+            "field": "expertise_domain",
+            "polarity": "positive",
+            "value": "operations",
+            "confidence": 0.7,
+            "observation_count": 1,
+            "source": "questionnaire"
+          }
+        ]
+      },
+      "decision_and_risk": {
+        "label": "Decision and risk",
+        "responses": [
+          {
+            "label": "Decision Threshold",
+            "question": "When do you commit?",
+            "answer": "Make sure I have covered the main risks before committing."
+          },
+          {
+            "label": "Value Tradeoffs",
+            "question": "What do you trade off?",
+            "answer": "Accuracy over speed; Thoroughness over simplicity."
+          }
+        ]
+      },
+      "behavioral": {
+        "label": "Working style",
+        "responses": [
+          {
+            "label": "Handling Ambiguity",
+            "question": "When a request is ambiguous?",
+            "answer": "Ask a clarifying question before doing anything."
+          }
+        ]
+      }
+    }
+  },
+  "phaedo_behavioral_signals": {
+    "surface": {
+      "too_long": 3,
+      "more_direct": 2
+    }
+  },
+  "phaedo_linguistic_profile": {
+    "messageCount": 64,
+    "avgWordCount": 28,
+    "imperativeRate": 0.18,
+    "platformDistribution": {
+      "Claude": 9,
+      "ChatGPT": 3
+    }
+  },
+  "phaedo_session_metrics": {
+    "sessionCount": 6,
+    "avgMessagesPerSession": 8
+  }
+}

package/server.js

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+// Phaedo MCP server — Phase 1 (push injection).
+//
+// Exposes the fingerprint projection to any MCP client (Claude Desktop, Claude
+// Code, Cursor, agent frameworks) per docs/protocol/mcp-binding.md:
+//   - tool      phaedo_request_injection      (§9.2 request → §9.3 response)
+//   - resource  phaedo://fingerprint/projection (default projection, all layers)
+//
+// Injection-only: MCP does not return the conversation, so there is NO capture
+// here (binding §5). Local stdio transport only in this cut.
+
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { readFileSync, existsSync } from 'fs';
+import { z } from 'zod';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+
+import { loadFingerprint } from './fingerprint-source.js';
+import { buildInjectionResponse, errorResponse, PhaedoError } from './projection.js';
+import { resolveConsultation, checkAuthorization, consultOptsFromEnv, CONSULTATION_TYPES } from './consult.js';
+import { defaultStateDir } from './cache.js';
+import { buildReceipt, appendReceipt, receiptsCapFromEnv } from './receipts.js';
+
+const BASE_DIR = dirname(fileURLToPath(import.meta.url));
+
+// §10.6 receipts: every resolved consultation gets an encrypted, append-only,
+// on-device receipt. Written AFTER resolution (the resolver stays pure) and
+// FAIL-SAFE: a receipt-write failure warns on stderr but never breaks the answer.
+const RECEIPTS_CAP = receiptsCapFromEnv(process.env);
+async function emitReceipt(via, args, response) {
+  try {
+    const receipt = buildReceipt({ via, agentId: args?.agent_id, request: args, response });
+    await appendReceipt(defaultStateDir(), receipt, { cap: RECEIPTS_CAP });
+  } catch (e) {
+    process.stderr.write(`[phaedo-mcp] receipt write failed (consultation still answered): ${e.message}\n`);
+  }
+}
+
+const CONSULT_OPTS = consultOptsFromEnv(process.env);
+// Deference policies: PHAEDO_CONSULT_POLICIES if set, else the default file beside
+// the server (mcp/consult-policies.json — what policy-editor.html produces). Zero
+// config: drop the file in and restart the client. (Portable vault policies in
+// phaedo_consult_policies always apply too, regardless of this file.)
+const POLICIES_PATH = process.env.PHAEDO_CONSULT_POLICIES || join(BASE_DIR, 'consult-policies.json');
+if (existsSync(POLICIES_PATH)) {
+  try { CONSULT_OPTS.policies = JSON.parse(readFileSync(POLICIES_PATH, 'utf8')); }
+  catch (e) { process.stderr.write(`[phaedo-mcp] ignoring malformed consult policies (${POLICIES_PATH}): ${e.message}\n`); }
+}
+
+const server = new McpServer({ name: 'phaedo', version: '0.1.0' });
+
+// ── Tool: phaedo_request_injection (binding §3.1) ─────────────────────────────
+server.registerTool(
+  'phaedo_request_injection',
+  {
+    title: 'Request a Phaedo fingerprint injection',
+    description:
+      "Returns the user's Phaedo cognitive-fingerprint projection as a system-prompt " +
+      'block to insert at the start of an AI session, so the assistant responds in the ' +
+      "user's style. Call once at session start and prepend the returned `projection`.",
+    inputSchema: {
+      session_context: z
+        .object({
+          platform: z.string().optional(),
+          task_hint: z.string().optional(),
+          audience_hint: z.string().optional(),
+          max_tokens: z.number().optional(),
+        })
+        .optional(),
+      mode: z.enum(['standard', 'enhanced_privacy']).optional(),
+      requested_layers: z.array(z.string()).optional(),
+      consumer_id: z.string().optional(),
+    },
+  },
+  async (args) => {
+    try {
+      const vd = await loadFingerprint(BASE_DIR);
+      const response = buildInjectionResponse(vd, args || {});
+      return {
+        content: [{ type: 'text', text: JSON.stringify(response, null, 2) }],
+        structuredContent: response,
+      };
+    } catch (err) {
+      // Surface as an MCP tool error carrying the §9.3 error response, with the
+      // §9.5 code preserved (binding §4).
+      const body = errorResponse(err);
+      const code = err instanceof PhaedoError ? err.code : 'internal_error';
+      return {
+        content: [{ type: 'text', text: `Phaedo injection error [${code}]: ${JSON.stringify(body)}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// ── Tool: phaedo_consult (binding §3.2, spec §10) ─────────────────────────────
+// Agent consultation: query the fingerprint at a decision point and get back a
+// constrained SIGNAL (§10.3) — never layer content (§10.4 boundary). One tool,
+// all four consultation types via `consultation_type`.
+server.registerTool(
+  'phaedo_consult',
+  {
+    title: 'Consult the Phaedo fingerprint at a decision point',
+    description:
+      "Ask how the user's cognitive pattern bears on a decision — without ingesting the fingerprint. " +
+      'Returns a signal (proceed | proceed_with_note | clarify | escalate | decline), a confidence, a ' +
+      'short rationale_hint, and a deference_level (how strongly to weight it). Use at agent decision points.',
+    inputSchema: {
+      consultation_type: z.enum(CONSULTATION_TYPES),
+      agent_id: z.string().optional(),
+      action_descriptor: z
+        .object({
+          domain: z.string().optional(),
+          reversible: z.boolean().optional(),
+          magnitude: z.enum(['low', 'medium', 'high']).optional(),
+          amount: z.number().optional(),
+          summary: z.string().optional(),
+        })
+        .optional(),
+      context: z.record(z.any()).optional(),
+    },
+  },
+  async (args) => {
+    try {
+      const vd = await loadFingerprint(BASE_DIR);
+      const response = await resolveConsultation(vd, args || {}, CONSULT_OPTS);
+      await emitReceipt('phaedo_consult', args, response); // every resolution, abstains included
+      return {
+        content: [{ type: 'text', text: JSON.stringify(response, null, 2) }],
+        structuredContent: response,
+      };
+    } catch (err) {
+      const body = errorResponse(err, 'consultation');
+      const code = err instanceof PhaedoError ? err.code : 'internal_error';
+      return {
+        content: [{ type: 'text', text: `Phaedo consultation error [${code}]: ${JSON.stringify(body)}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// ── Tool: phaedo_check_authorization (binding §3.2, spec §10.5) ───────────────
+// Lightweight, DETERMINISTIC-only pre-flight: does a standing authorization
+// (§10.5 force rule) already decide this action? Skips inferred evaluation and the
+// model judge entirely — a fast check an agent runs before a full phaedo_consult.
+// Returns { authorization_matched, signal, rule_id, rationale_hint }; a match is the
+// subject's pre-decision (confidence 1.0 / deference high, by definition). Never
+// returns layer content (§10.4).
+server.registerTool(
+  'phaedo_check_authorization',
+  {
+    title: 'Check standing authorizations for an action',
+    description:
+      "Deterministic pre-flight: check whether one of the user's standing authorizations " +
+      '(§10.5) already decides this action — escalate, decline, or pre-approve — without running ' +
+      'the full consultation. Returns authorization_matched plus the authorized signal and the ' +
+      'rule that fired. If no rule matches, fall back to phaedo_consult or your own default.',
+    inputSchema: {
+      consultation_type: z.enum(CONSULTATION_TYPES).optional(),
+      agent_id: z.string().optional(),
+      action_descriptor: z
+        .object({
+          domain: z.string().optional(),
+          reversible: z.boolean().optional(),
+          magnitude: z.enum(['low', 'medium', 'high']).optional(),
+          amount: z.number().optional(),
+          summary: z.string().optional(),
+        })
+        .optional(),
+    },
+  },
+  async (args) => {
+    try {
+      const req = { consultation_type: 'action_approval', ...(args || {}) };
+      const vd = await loadFingerprint(BASE_DIR);
+      const response = checkAuthorization(vd, req, CONSULT_OPTS);
+      // A matched pre-flight IS a resolved decision (the authorization fired) →
+      // receipt. A no-match is not a decision — no receipt (keeps the store from
+      // filling with probes; the follow-up phaedo_consult writes its own).
+      if (response.authorization_matched) {
+        await emitReceipt('phaedo_check_authorization', req, { signal: response.signal, confidence: 1.0, deference_level: 'high' });
+      }
+      return {
+        content: [{ type: 'text', text: JSON.stringify(response, null, 2) }],
+        structuredContent: response,
+      };
+    } catch (err) {
+      const body = errorResponse(err, 'authorization_check');
+      const code = err instanceof PhaedoError ? err.code : 'internal_error';
+      return {
+        content: [{ type: 'text', text: `Phaedo authorization-check error [${code}]: ${JSON.stringify(body)}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// ── Resource: phaedo://fingerprint/projection (binding §3.1) ──────────────────
+// Default projection (all layers, standard mode) for resource-only clients.
+server.registerResource(
+  'phaedo-projection',
+  'phaedo://fingerprint/projection',
+  {
+    title: 'Phaedo fingerprint projection',
+    description: 'Default Phaedo injection projection (all layers, standard mode).',
+    mimeType: 'text/plain',
+  },
+  async (uri) => {
+    const vd = await loadFingerprint(BASE_DIR);
+    const response = buildInjectionResponse(vd, { requested_layers: ['all'], mode: 'standard' });
+    return { contents: [{ uri: uri.href, mimeType: 'text/plain', text: response.projection }] };
+  }
+);
+
+// ── Prompt: phaedo (one-click session-start injection) ────────────────────────
+// MCP prompts surface in clients as a user-invokable command (a `/phaedo` slash
+// command in Claude Desktop / Claude Code). Selecting it inserts the projection
+// as a conversation message, so the user gets near-automatic injection without
+// having to ask the model to call the tool. The text is rendered by the SAME
+// context-block path as the tool/resource — byte-identical injection.
+server.registerPrompt(
+  'phaedo',
+  {
+    title: 'Load my Phaedo fingerprint',
+    description:
+      "Insert your Phaedo cognitive-fingerprint projection so the assistant responds in your " +
+      "style. Run once at the start of a session.",
+  },
+  async () => {
+    const vd = await loadFingerprint(BASE_DIR);
+    const response = buildInjectionResponse(vd, { requested_layers: ['all'], mode: 'standard' });
+    return {
+      messages: [
+        {
+          role: 'user',
+          content: {
+            type: 'text',
+            text:
+              'The following is my Phaedo cognitive fingerprint — a profile of how I think, ' +
+              'communicate, and want responses formatted. Treat it as authoritative guidance for ' +
+              'the rest of this conversation, and do not announce that you read it.\n\n' +
+              response.projection,
+          },
+        },
+      ],
+    };
+  }
+);
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  // stdio transport owns stdout for protocol framing — never console.log here.
+  process.stderr.write('[phaedo-mcp] ready on stdio\n');
+}
+
+main().catch((err) => {
+  process.stderr.write(`[phaedo-mcp] fatal: ${err.stack || err}\n`);
+  process.exit(1);
+});

package/server.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.galavoxx/phaedo",
+  "description": "Carry your Phaedo cognitive fingerprint into any MCP client: inject your style at session start, and consult your decision pattern (proceed/clarify/escalate/decline) at agent decision points. Local, user-owned, privacy-preserving.",
+  "version": "0.1.0",
+  "repository": {
+    "url": "https://github.com/galavoxx/phaedo",
+    "source": "github"
+  },
+  "packages": [
+    {
+      "registryType": "npm",
+      "registryBaseUrl": "https://registry.npmjs.org",
+      "identifier": "phaedo-mcp",
+      "version": "0.1.0",
+      "transport": { "type": "stdio" }
+    }
+  ]
+}