@redaksjon/protokoll 1.0.26 → 1.0.27-dev.20260305054841.9de8b06

package/dist/mcp/server-hono.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import 'dotenv/config';
 import { scryptSync, timingSafeEqual, randomUUID, createHash } from 'node:crypto';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { Command } from 'commander';
 import { Hono } from 'hono';
 import { serve } from '@hono/node-server';
@@ -11,17 +12,17 @@ import { bodyLimit } from 'hono/body-limit';
 import { join, isAbsolute, relative, extname, basename, resolve, dirname } from 'node:path';
 import * as fs from 'node:fs/promises';
 import { readFile, mkdir, access } from 'node:fs/promises';
+import { tmpdir, homedir } from 'node:os';
 import { glob } from 'glob';
+import yaml__default, { load } from 'js-yaml';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { ListRootsRequestSchema, ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import * as Cardigantime from '@utilarium/cardigantime';
 import Logging from '@fjell/logging';
 import { z } from 'zod';
-import { m as markTranscriptIndexDirtyForStorage, j as getOutputDirectory, k as getOutputStorage, D as DEFAULT_CONFIG_FILE, s as setRoots, l as getServerConfig, n as getStorageConfig, o as getContext, c as configureEngineLoggingBridge, p as createQuietLogger, t as tools, h as handleToolCall, a as handleListResources, b as handleReadResource, g as getPrompts, d as getPrompt, q as isInitialized, e as initializeServerConfig, f as getCachedRoots, r as setWorkerInstance } from '../engineLogging.js';
-import { tmpdir } from 'node:os';
+import { m as markTranscriptIndexDirtyForStorage, j as getOutputDirectory, k as getOutputStorage, D as DEFAULT_CONFIG_FILE, s as setRoots, l as getServerConfig, n as getStorageConfig, o as getContext, c as configureEngineLoggingBridge, p as createQuietLogger, t as tools, h as handleToolCall, a as handleListResources, q as parseUri, r as handleReadTranscript, u as readTranscriptsListResource, b as handleReadResource, g as getPrompts, d as getPrompt, v as isInitialized, e as initializeServerConfig, f as getCachedRoots, w as setWorkerInstance } from '../engineLogging.js';
 import { Transcript, Weighting, Pipeline } from '@redaksjon/protokoll-engine';
 import { PklTranscript } from '@redaksjon/protokoll-format';
-import yaml__default from 'js-yaml';
 import 'node:fs';
 import 'node:url';
 import '@redaksjon/context';
@@ -916,7 +917,8 @@ function parseKeys(value) {
       user_id: userId,
       secret_hash: secretHash,
       enabled: asBooleanWithDefault(obj.enabled, true),
-      expires_at: asString(obj.expires_at) ?? void 0
+      expires_at: asString(obj.expires_at) ?? void 0,
+      allowed_projects: asStringArray(obj.allowed_projects)
     };
   });
 }
@@ -1068,7 +1070,8 @@ function createRbacAuthorizer(config) {
         context: {
           user_id: user.user_id,
           roles: [...user.roles],
-          key_id: key.key_id
+          key_id: key.key_id,
+          allowed_projects: key.allowed_projects && key.allowed_projects.length > 0 ? [...key.allowed_projects] : void 0
         }
       };
     },
@@ -1231,6 +1234,164 @@ function buildEnvStorageConfig() {
   if (hasGcsValue) storage.gcs = gcs;
   return storage;
 }
+function readAbsolutePath(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("/")) return void 0;
+  return trimmed;
+}
+function readAbsolutePathList(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry.startsWith("/"));
+}
+function commonAncestor(paths) {
+  if (paths.length === 0) {
+    return null;
+  }
+  const normalized = paths.map((pathValue) => resolve(pathValue));
+  const [first, ...rest] = normalized;
+  let current = first;
+  while (current !== dirname(current)) {
+    const matches = rest.every((entry) => entry === current || entry.startsWith(`${current}/`));
+    if (matches) {
+      return current;
+    }
+    current = dirname(current);
+  }
+  return rest.every((entry) => entry === current || entry.startsWith(`${current}/`)) ? current : null;
+}
+function hasStorageConfig(config) {
+  return typeof config.storage === "object" && config.storage !== null;
+}
+async function mergeStorageFromCanonicalConfig(config, explicitConfigPath) {
+  if (hasStorageConfig(config)) {
+    return config;
+  }
+  const roots = [
+    readAbsolutePath(config.inputDirectory),
+    readAbsolutePath(config.outputDirectory),
+    readAbsolutePath(config.processedDirectory),
+    ...readAbsolutePathList(config.contextDirectories)
+  ].filter((value) => Boolean(value));
+  if (roots.length === 0) {
+    return config;
+  }
+  const ancestor = commonAncestor(roots.map((value) => dirname(value)));
+  if (!ancestor) {
+    return config;
+  }
+  const canonicalConfigPath = resolve(ancestor, DEFAULT_CONFIG_FILE);
+  if (explicitConfigPath && resolve(explicitConfigPath) === canonicalConfigPath) {
+    return config;
+  }
+  try {
+    const rawCanonicalConfig = await readFile(canonicalConfigPath, "utf8");
+    const parsed = load(rawCanonicalConfig);
+    if (!parsed || typeof parsed !== "object") {
+      return config;
+    }
+    const candidate = parsed;
+    if (!hasStorageConfig(candidate)) {
+      return config;
+    }
+    lifecycleLogger.info("startup.storage.recovered_from_canonical_config", {
+      canonicalConfigPath,
+      inferredFromRoots: roots
+    });
+    return {
+      ...config,
+      storage: candidate.storage
+    };
+  } catch {
+    return config;
+  }
+}
+function exportStorageConfigToEnv(config) {
+  const storage = config.storage && typeof config.storage === "object" ? config.storage : null;
+  if (!storage) {
+    return;
+  }
+  const backend = typeof storage.backend === "string" ? storage.backend.trim() : "";
+  if (backend !== "gcs") {
+    return;
+  }
+  const gcs = storage.gcs && typeof storage.gcs === "object" ? storage.gcs : {};
+  const setIfMissing = (name, value) => {
+    if (typeof process.env[name] === "string" && process.env[name].trim().length > 0) {
+      return;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+      process.env[name] = value.trim();
+    }
+  };
+  setIfMissing("PROTOKOLL_STORAGE_BACKEND", "gcs");
+  setIfMissing("PROTOKOLL_STORAGE_GCS_PROJECT_ID", gcs.projectId);
+  setIfMissing("PROTOKOLL_STORAGE_GCS_INPUT_URI", gcs.inputUri);
+  setIfMissing("PROTOKOLL_STORAGE_GCS_OUTPUT_URI", gcs.outputUri);
+  setIfMissing("PROTOKOLL_STORAGE_GCS_CONTEXT_URI", gcs.contextUri);
+  setIfMissing("PROTOKOLL_STORAGE_GCS_INPUT_BUCKET", gcs.inputBucket);
+  setIfMissing("PROTOKOLL_STORAGE_GCS_INPUT_PREFIX", gcs.inputPrefix);
+  setIfMissing("PROTOKOLL_STORAGE_GCS_OUTPUT_BUCKET", gcs.outputBucket);
+  setIfMissing("PROTOKOLL_STORAGE_GCS_OUTPUT_PREFIX", gcs.outputPrefix);
+  setIfMissing("PROTOKOLL_STORAGE_GCS_CONTEXT_BUCKET", gcs.contextBucket);
+  setIfMissing("PROTOKOLL_STORAGE_GCS_CONTEXT_PREFIX", gcs.contextPrefix);
+  setIfMissing("PROTOKOLL_STORAGE_GCS_CREDENTIALS_FILE", gcs.credentialsFile);
+}
+function readCredentialsEnvPath() {
+  const candidates = [
+    process.env.PROTOKOLL_STORAGE_GCS_CREDENTIALS_FILE,
+    process.env.PROTOKOLL_LOCAL_GCS_CREDENTIALS_FILE,
+    process.env.GOOGLE_APPLICATION_CREDENTIALS
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim().length > 0) {
+      const trimmed = candidate.trim();
+      return trimmed.startsWith("~/") ? resolve(homedir(), trimmed.slice(2)) : trimmed;
+    }
+  }
+  return void 0;
+}
+async function injectLocalGcsCredentialsIfMissing(config) {
+  const storage = config.storage && typeof config.storage === "object" ? config.storage : null;
+  if (!storage) {
+    return config;
+  }
+  if (storage.backend !== "gcs") {
+    return config;
+  }
+  const gcs = storage.gcs && typeof storage.gcs === "object" ? storage.gcs : {};
+  const existingCredentials = readNonEmptyString(gcs.credentialsFile);
+  if (existingCredentials) {
+    return config;
+  }
+  const explicitFromEnv = readCredentialsEnvPath();
+  const defaultLocalPath = resolve(homedir(), ".ssh/gcp-discursive-riotplan-service.json");
+  const credentialCandidates = [
+    explicitFromEnv,
+    defaultLocalPath
+  ].filter((value) => Boolean(value));
+  for (const candidate of credentialCandidates) {
+    try {
+      await access(candidate);
+      lifecycleLogger.info("startup.storage.gcs.credentials.injected", {
+        path: candidate,
+        source: candidate === explicitFromEnv ? "env" : "local_default"
+      });
+      return {
+        ...config,
+        storage: {
+          ...storage,
+          gcs: {
+            ...gcs,
+            credentialsFile: candidate
+          }
+        }
+      };
+    } catch {
+    }
+  }
+  return config;
+}
 function describeRawStorageConfig(config) {
   const lines = [];
   const rawStorage = config.storage;
@@ -1373,6 +1534,269 @@ function getAuthorizationHeaderSummary(c) {
   if (hasApiKey) return "x-api-key";
   return "none";
 }
+const authContextStore = new AsyncLocalStorage();
+function getActiveAuthContext() {
+  return authContextStore.getStore() ?? null;
+}
+function normalizeAllowedProjects(auth) {
+  if (!auth?.allowed_projects || auth.allowed_projects.length === 0) {
+    return [];
+  }
+  return auth.allowed_projects.map((value) => value.trim()).filter(Boolean);
+}
+function isProjectAllowed(projectId, allowedProjects) {
+  if (!projectId) return false;
+  const normalized = projectId.trim().toLowerCase();
+  return allowedProjects.some((allowed) => allowed.toLowerCase() === normalized);
+}
+function hasProjectScope(auth) {
+  return normalizeAllowedProjects(auth).length > 0;
+}
+function asRecord(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function extractTranscriptRefs(args) {
+  const refs = [];
+  const directKeys = ["transcriptPath", "sourceTranscriptPath", "targetTranscriptPath"];
+  for (const key of directKeys) {
+    const value = args[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      refs.push(value.trim());
+    }
+  }
+  const listValue = args.transcriptPaths;
+  if (Array.isArray(listValue)) {
+    for (const entry of listValue) {
+      if (typeof entry === "string" && entry.trim().length > 0) {
+        refs.push(entry.trim());
+      }
+    }
+  }
+  return refs;
+}
+async function enforceProjectScopeForTool(toolName, args, authContext) {
+  const allowedProjects = normalizeAllowedProjects(authContext);
+  if (allowedProjects.length === 0) {
+    return args;
+  }
+  const scopedArgs = asRecord(args);
+  const contextDirectory = typeof scopedArgs.contextDirectory === "string" ? scopedArgs.contextDirectory : void 0;
+  if (toolName === "protokoll_list_transcripts") {
+    const entityType = typeof scopedArgs.entityType === "string" ? scopedArgs.entityType.trim() : "";
+    const entityId = typeof scopedArgs.entityId === "string" ? scopedArgs.entityId.trim() : "";
+    if (entityType && entityType !== "project") {
+      throw new Error('This API key is project-scoped. Use entityType="project" with an allowed entityId.');
+    }
+    if (entityId) {
+      if (!isProjectAllowed(entityId, allowedProjects)) {
+        throw new Error(`Project-scoped key cannot access project "${entityId}".`);
+      }
+      return {
+        ...scopedArgs,
+        entityType: "project",
+        entityId
+      };
+    }
+    if (allowedProjects.length === 1) {
+      return {
+        ...scopedArgs,
+        entityType: "project",
+        entityId: allowedProjects[0]
+      };
+    }
+    throw new Error('This API key is scoped to multiple projects. Provide entityType="project" and an allowed entityId.');
+  }
+  if (toolName === "protokoll_create_note" || toolName === "protokoll_process_audio") {
+    const providedProject = typeof scopedArgs.projectId === "string" ? scopedArgs.projectId.trim() : "";
+    if (providedProject) {
+      if (!isProjectAllowed(providedProject, allowedProjects)) {
+        throw new Error(`Project-scoped key cannot write to project "${providedProject}".`);
+      }
+      return args;
+    }
+    if (allowedProjects.length === 1) {
+      return {
+        ...scopedArgs,
+        projectId: allowedProjects[0]
+      };
+    }
+    throw new Error("This API key is scoped to multiple projects. Provide an explicit allowed projectId.");
+  }
+  if (toolName === "protokoll_add_term") {
+    const provided = Array.isArray(scopedArgs.projects) ? scopedArgs.projects.filter((value) => typeof value === "string" && value.trim().length > 0) : [];
+    if (provided.length > 0) {
+      for (const projectId of provided) {
+        if (!isProjectAllowed(projectId, allowedProjects)) {
+          throw new Error(`Project-scoped key cannot attach term to project "${projectId}".`);
+        }
+      }
+      return args;
+    }
+    if (allowedProjects.length === 1) {
+      return {
+        ...scopedArgs,
+        projects: [allowedProjects[0]]
+      };
+    }
+    throw new Error("This API key is scoped to multiple projects. Provide explicit allowed projects when creating a term.");
+  }
+  if (toolName === "protokoll_edit_term") {
+    const replaceProjects = Array.isArray(scopedArgs.projects) ? scopedArgs.projects.filter((value) => typeof value === "string" && value.trim().length > 0) : null;
+    const addProjects = Array.isArray(scopedArgs.add_projects) ? scopedArgs.add_projects.filter((value) => typeof value === "string" && value.trim().length > 0) : [];
+    const removeProjects = Array.isArray(scopedArgs.remove_projects) ? scopedArgs.remove_projects.filter((value) => typeof value === "string" && value.trim().length > 0) : [];
+    const validateProjectList = (values, action) => {
+      for (const projectId of values) {
+        if (!isProjectAllowed(projectId, allowedProjects)) {
+          throw new Error(`Project-scoped key cannot ${action} project "${projectId}".`);
+        }
+      }
+    };
+    if (replaceProjects) validateProjectList(replaceProjects, "set");
+    if (addProjects.length > 0) validateProjectList(addProjects, "add");
+    if (removeProjects.length > 0) validateProjectList(removeProjects, "remove");
+    return args;
+  }
+  if (toolName === "protokoll_add_person" || toolName === "protokoll_add_company") {
+    if (allowedProjects.length !== 1) {
+      throw new Error("This API key is scoped to multiple projects. Person/company creation currently requires a single allowed project.");
+    }
+    return args;
+  }
+  if (toolName === "protokoll_edit_project" || toolName === "protokoll_update_project") {
+    const projectId = typeof scopedArgs.id === "string" ? scopedArgs.id.trim() : "";
+    if (!projectId || !isProjectAllowed(projectId, allowedProjects)) {
+      throw new Error("Project-scoped key can only modify its allowed project.");
+    }
+    return args;
+  }
+  if (toolName === "protokoll_add_project" || toolName === "protokoll_delete_entity") {
+    throw new Error("Project-scoped keys cannot create or delete projects/entities.");
+  }
+  if (toolName === "protokoll_get_entity") {
+    const entityType = typeof scopedArgs.entityType === "string" ? scopedArgs.entityType.trim() : "";
+    const entityId = typeof scopedArgs.entityId === "string" ? scopedArgs.entityId.trim() : "";
+    if (entityType !== "project") {
+      throw new Error("Project-scoped keys can only read project entities from context.");
+    }
+    if (!isProjectAllowed(entityId, allowedProjects)) {
+      throw new Error(`Project-scoped key cannot access project "${entityId}".`);
+    }
+    return args;
+  }
+  if (toolName === "protokoll_list_projects") {
+    return args;
+  }
+  if (toolName === "protokoll_context_status" || toolName === "protokoll_list_people" || toolName === "protokoll_list_terms" || toolName === "protokoll_list_companies" || toolName === "protokoll_search_context") {
+    throw new Error(`Project-scoped key cannot call ${toolName}. Use project-scoped transcript/note tools and explicit project lookups.`);
+  }
+  if (toolName === "protokoll_edit_transcript") {
+    const requestedProject = typeof scopedArgs.projectId === "string" ? scopedArgs.projectId.trim() : "";
+    if (requestedProject && !isProjectAllowed(requestedProject, allowedProjects)) {
+      throw new Error(`Project-scoped key cannot move transcripts to project "${requestedProject}".`);
+    }
+  }
+  if (toolName === "protokoll_get_transcript_by_uuid") {
+    const uuid = typeof scopedArgs.uuid === "string" ? scopedArgs.uuid.trim() : "";
+    if (uuid) {
+      const readResult = await handleReadTranscript({ transcriptPath: uuid, contextDirectory });
+      const metadata = asRecord(readResult.metadata);
+      const projectId = typeof metadata.projectId === "string" ? metadata.projectId.trim() : "";
+      if (!isProjectAllowed(projectId, allowedProjects)) {
+        throw new Error(`Project-scoped key cannot access transcript from project "${projectId || "unassigned"}".`);
+      }
+    }
+    return args;
+  }
+  const transcriptRefs = extractTranscriptRefs(scopedArgs);
+  if (transcriptRefs.length === 0) {
+    return args;
+  }
+  for (const transcriptRef of transcriptRefs) {
+    const readResult = await handleReadTranscript({
+      transcriptPath: transcriptRef,
+      contextDirectory
+    });
+    const metadata = asRecord(readResult.metadata);
+    const projectId = typeof metadata.projectId === "string" ? metadata.projectId.trim() : "";
+    if (!isProjectAllowed(projectId, allowedProjects)) {
+      throw new Error(`Project-scoped key cannot access transcript from project "${projectId || "unassigned"}".`);
+    }
+  }
+  return args;
+}
+function filterProjectScopedToolResult(toolName, result, authContext) {
+  const allowedProjects = normalizeAllowedProjects(authContext);
+  if (allowedProjects.length === 0) {
+    return result;
+  }
+  if (toolName === "protokoll_list_projects") {
+    const payload = asRecord(result);
+    const projectsRaw = payload.projects;
+    const projects = Array.isArray(projectsRaw) ? projectsRaw.filter((project) => {
+      const item = asRecord(project);
+      const id = typeof item.id === "string" ? item.id.trim() : "";
+      return isProjectAllowed(id, allowedProjects);
+    }) : [];
+    return {
+      ...payload,
+      projects,
+      total: projects.length,
+      count: projects.length
+    };
+  }
+  return result;
+}
+async function postProcessProjectScopedCreate(toolName, args, result, authContext) {
+  const allowedProjects = normalizeAllowedProjects(authContext);
+  if (allowedProjects.length !== 1) {
+    return;
+  }
+  const scopedProjectId = allowedProjects[0];
+  const payload = asRecord(result);
+  const entity = asRecord(payload.entity);
+  const entityId = typeof entity.id === "string" ? entity.id.trim() : "";
+  if (!entityId) {
+    return;
+  }
+  if (toolName === "protokoll_add_person") {
+    await handleToolCall("protokoll_edit_project", {
+      id: scopedProjectId,
+      add_associated_people: [entityId],
+      contextDirectory: asRecord(args).contextDirectory
+    });
+  }
+  if (toolName === "protokoll_add_company") {
+    await handleToolCall("protokoll_edit_project", {
+      id: scopedProjectId,
+      add_associated_companies: [entityId],
+      contextDirectory: asRecord(args).contextDirectory
+    });
+  }
+}
+function filterProjectEntitiesResourceJson(contents, allowedProjects) {
+  if (!contents.text) {
+    return contents;
+  }
+  try {
+    const parsed = JSON.parse(contents.text);
+    const entities = Array.isArray(parsed.entities) ? parsed.entities : [];
+    const filtered = entities.filter((entity) => {
+      const item = asRecord(entity);
+      const id = typeof item.id === "string" ? item.id.trim() : "";
+      return isProjectAllowed(id, allowedProjects);
+    });
+    return {
+      ...contents,
+      text: JSON.stringify({
+        ...parsed,
+        entities: filtered,
+        count: filtered.length
+      }, null, 2)
+    };
+  } catch {
+    return contents;
+  }
+}
 async function configureRbacIfSecured(config) {
   if (rbacReloadTimer) {
     clearInterval(rbacReloadTimer);
@@ -1580,12 +2004,18 @@ function createMcpServer() {
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     const startedAt = Date.now();
+    const authContext = getActiveAuthContext();
     requestLogger.info("tool.call.start", {
       toolName: name,
-      args: summarizeToolArgs(args)
+      args: summarizeToolArgs(args),
+      userId: authContext?.user_id ?? null,
+      keyId: authContext?.key_id ?? null
     });
     try {
-      const result = await handleToolCall(name, args);
+      const scopedArgs = await enforceProjectScopeForTool(name, args, authContext);
+      const toolResult = await handleToolCall(name, scopedArgs);
+      await postProcessProjectScopedCreate(name, scopedArgs, toolResult, authContext);
+      const result = filterProjectScopedToolResult(name, toolResult, authContext);
       sendEntityChangeNotifications(name, args).catch((err) => {
         rootLogger.error("entity.notification.dispatch_error", {
           toolName: name,
@@ -1622,12 +2052,99 @@ function createMcpServer() {
     }
   });
   server.setRequestHandler(ListResourcesRequestSchema, async () => {
-    return handleListResources();
+    const listed = await handleListResources();
+    const authContext = getActiveAuthContext();
+    if (!hasProjectScope(authContext)) {
+      return listed;
+    }
+    const filteredResources = listed.resources.filter((resource) => {
+      try {
+        const parsed = parseUri(resource.uri);
+        if (parsed.resourceType === "entities-list") {
+          return parsed.entityType === "project";
+        }
+        if (parsed.resourceType === "entity") {
+          return parsed.entityType === "project" && isProjectAllowed(parsed.entityId, normalizeAllowedProjects(authContext));
+        }
+        if (parsed.resourceType === "audio-inbound" || parsed.resourceType === "audio-processed") {
+          return false;
+        }
+        return true;
+      } catch {
+        return true;
+      }
+    });
+    return {
+      ...listed,
+      resources: filteredResources
+    };
   });
   server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
     const { uri } = request.params;
+    const authContext = getActiveAuthContext();
+    const allowedProjects = normalizeAllowedProjects(authContext);
+    if (allowedProjects.length > 0) {
+      const parsed = parseUri(uri);
+      if (parsed.resourceType === "audio-inbound" || parsed.resourceType === "audio-processed" || parsed.resourceType === "config") {
+        throw new Error(`Project-scoped key cannot access ${parsed.resourceType} resources`);
+      }
+      if (parsed.resourceType === "entity") {
+        const entity = parsed;
+        if (entity.entityType !== "project") {
+          throw new Error("Project-scoped key can only read project entities");
+        }
+        if (!isProjectAllowed(entity.entityId, allowedProjects)) {
+          throw new Error(`Project-scoped key cannot access project "${entity.entityId}"`);
+        }
+      }
+      if (parsed.resourceType === "entities-list") {
+        const entityList = parsed;
+        if (entityList.entityType !== "project") {
+          throw new Error("Project-scoped key can only list project entities");
+        }
+      }
+      if (parsed.resourceType === "transcript") {
+        const transcriptUri = parsed;
+        const transcriptResult = await handleReadTranscript({
+          transcriptPath: transcriptUri.transcriptPath
+        });
+        const metadata = asRecord(transcriptResult.metadata);
+        const projectId = typeof metadata.projectId === "string" ? metadata.projectId.trim() : "";
+        if (!isProjectAllowed(projectId, allowedProjects)) {
+          throw new Error(`Project-scoped key cannot access transcript from project "${projectId || "unassigned"}"`);
+        }
+      }
+      if (parsed.resourceType === "transcripts-list") {
+        const list = parsed;
+        const requestedProjectId = typeof list.projectId === "string" ? list.projectId.trim() : "";
+        if (requestedProjectId.length > 0 && !isProjectAllowed(requestedProjectId, allowedProjects)) {
+          throw new Error(`Project-scoped key cannot list transcripts for project "${requestedProjectId}"`);
+        }
+        if (requestedProjectId.length === 0) {
+          if (allowedProjects.length !== 1) {
+            throw new Error("Project-scoped key with multiple projects must specify projectId in transcript list resource");
+          }
+          const contents = await readTranscriptsListResource({
+            directory: list.directory,
+            startDate: list.startDate,
+            endDate: list.endDate,
+            limit: list.limit,
+            offset: list.offset,
+            projectId: allowedProjects[0]
+          });
+          return { contents: [contents] };
+        }
+      }
+    }
     try {
       const contents = await handleReadResource(uri);
+      if (allowedProjects.length > 0) {
+        const parsed = parseUri(uri);
+        if (parsed.resourceType === "entities-list") {
+          const filtered = filterProjectEntitiesResourceJson(contents, allowedProjects);
+          return { contents: [filtered] };
+        }
+      }
       return { contents: [contents] };
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -1806,7 +2323,19 @@ app.post(
       const rawTitle = body["title"];
       const rawProject = body["project"];
       const title = typeof rawTitle === "string" && rawTitle.trim() ? rawTitle.trim() : void 0;
-      const project = typeof rawProject === "string" && rawProject.trim() ? rawProject.trim() : void 0;
+      let project = typeof rawProject === "string" && rawProject.trim() ? rawProject.trim() : void 0;
+      const authContext = c.get(AUTH_CONTEXT_KEY);
+      if (hasProjectScope(authContext ?? null)) {
+        const allowedProjects = normalizeAllowedProjects(authContext ?? null);
+        if (!project && allowedProjects.length === 1) {
+          project = allowedProjects[0];
+        }
+        if (!project || !isProjectAllowed(project, allowedProjects)) {
+          return c.json({
+            error: "Project-scoped key cannot upload outside allowed projects"
+          }, 403);
+        }
+      }
       await mkdir(outputDir, { recursive: true });
       const { uuid, filePath } = await createUploadTranscript({
         audioFile: basename(uploadObjectPath),
@@ -1862,6 +2391,14 @@ app.get("/audio/:uuid", async (c) => {
     const transcript = PklTranscript.open(filePath, { readOnly: true });
     const metadata = transcript.metadata;
     await transcript.close();
+    const authContext = c.get(AUTH_CONTEXT_KEY);
+    if (hasProjectScope(authContext ?? null)) {
+      const allowedProjects = normalizeAllowedProjects(authContext ?? null);
+      const projectId = typeof metadata.projectId === "string" ? metadata.projectId : null;
+      if (!isProjectAllowed(projectId, allowedProjects)) {
+        return c.json({ error: "Project-scoped key cannot access this transcript audio" }, 403);
+      }
+    }
     if (!metadata.audioHash) {
       return c.json({ error: "No audio file associated with this transcript" }, 404);
     }
@@ -1928,7 +2465,8 @@ app.get("/auth/whoami", async (c) => {
   return c.json({
     user_id: auth.user_id,
     roles: auth.roles,
-    key_id: auth.key_id
+    key_id: auth.key_id,
+    allowed_projects: auth.allowed_projects ?? []
   });
 });
 app.get("/admin/ping", async (c) => {
@@ -2154,7 +2692,11 @@ app.post("/mcp", async (c) => {
     rpcId: jsonRpcMessage.id ?? null,
     elapsedMs: Date.now() - requestStartedAt
   });
-  const response = await session.transport.handleRequest(c);
+  const requestAuthContext = c.get(AUTH_CONTEXT_KEY) ?? null;
+  const response = await authContextStore.run(
+    requestAuthContext,
+    () => session.transport.handleRequest(c)
+  );
   requestLogger.debug("complete", {
     method: "POST",
     route: "/mcp",
@@ -2280,6 +2822,9 @@ async function main() {
   await cardigantime.configure(program);
   program.parse();
   const args = program.opts();
+  const securedFromCli = program.getOptionValueSource("secured") === "cli" ? Boolean(args.secured) : void 0;
+  const debugFromCli = program.getOptionValueSource("debug") === "cli" ? Boolean(args.debug) : void 0;
+  const verboseFromCli = program.getOptionValueSource("verbose") === "cli" ? Boolean(args.verbose) : void 0;
   if (args.cwd) {
     process.chdir(resolve(args.cwd));
   }
@@ -2305,7 +2850,7 @@ async function main() {
     process.env.PROTOKOLL_CONFIG = configPath;
     process.env.WORKSPACE_ROOT = dirname(configPath);
   }
-  const cardigantimeConfig = await cardigantime.read({
+  let cardigantimeConfig = await cardigantime.read({
     ...args,
     inputDirectory: args.inputDirectory ?? process.env.PROTOKOLL_INPUT_DIRECTORY,
     outputDirectory: args.outputDirectory ?? process.env.PROTOKOLL_OUTPUT_DIRECTORY,
@@ -2315,15 +2860,23 @@ async function main() {
     classifyModel: args.classifyModel ?? process.env.PROTOKOLL_CLASSIFY_MODEL,
     composeModel: args.composeModel ?? process.env.PROTOKOLL_COMPOSE_MODEL,
     transcriptionModel: args.transcriptionModel ?? process.env.PROTOKOLL_TRANSCRIPTION_MODEL,
-    secured: args.secured ?? parseBooleanEnv(process.env.PROTOKOLL_HTTP_SECURED),
+    secured: securedFromCli ?? parseBooleanEnv(process.env.PROTOKOLL_HTTP_SECURED),
     rbacUsersPath: args.rbacUsersPath ?? process.env.RBAC_USERS_PATH,
     rbacKeysPath: args.rbacKeysPath ?? process.env.RBAC_KEYS_PATH,
     rbacPolicyPath: args.rbacPolicyPath ?? process.env.RBAC_POLICY_PATH,
     rbacReloadSeconds: args.rbacReloadSeconds ?? process.env.RBAC_RELOAD_SECONDS,
-    debug: args.debug ?? parseBooleanEnv(process.env.PROTOKOLL_DEBUG),
-    verbose: args.verbose ?? parseBooleanEnv(process.env.PROTOKOLL_VERBOSE),
+    debug: debugFromCli ?? parseBooleanEnv(process.env.PROTOKOLL_DEBUG),
+    verbose: verboseFromCli ?? parseBooleanEnv(process.env.PROTOKOLL_VERBOSE),
     storage: buildEnvStorageConfig()
   });
+  cardigantimeConfig = await mergeStorageFromCanonicalConfig(
+    cardigantimeConfig,
+    args.config
+  );
+  cardigantimeConfig = await injectLocalGcsCredentialsIfMissing(
+    cardigantimeConfig
+  );
+  exportStorageConfigToEnv(cardigantimeConfig);
   configureHttpLogLevel(cardigantimeConfig.debug === true);
   if (!args.config) {
     const resolvedConfigDirs = cardigantimeConfig.resolvedConfigDirs;