@redaksjon/protokoll 1.0.21 → 1.0.22-dev.20260227214704.08e3d54

package/dist/configDiscovery.js

@@ -1,18 +1,21 @@
-import { resolve, isAbsolute, relative, extname, join, dirname, basename } from 'node:path';
+import { isAbsolute, resolve, relative, dirname, join, basename, extname } from 'node:path';
+import os, { tmpdir } from 'node:os';
+import * as fs from 'node:fs/promises';
+import { readFile, mkdir, writeFile, rm, stat, readdir, access, mkdtemp, unlink } from 'node:fs/promises';
+import Logging from '@fjell/logging';
 import * as Metadata from '@redaksjon/protokoll-engine';
 import { Transcript, Media, Util, Pipeline, findIgnoredResilient, findCompanyResilient, findTermResilient, findPersonResilient, findProjectResilient, Routing, Phases, Reasoning, Agentic, VALID_STATUSES, isValidStatus } from '@redaksjon/protokoll-engine';
+import { PklTranscript, readTranscript, listTranscripts as listTranscripts$1 } from '@redaksjon/protokoll-format';
 import * as yaml from 'js-yaml';
-import { stat, readdir, mkdir, mkdtemp, rm, unlink } from 'node:fs/promises';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { create as create$1, parseEntityUri as parseEntityUri$1, createRelationship, createDocumentContent, createCodeContent, createMarkdownContent, createTextContent, createUrlContent } from '@redaksjon/context';
-import os, { tmpdir } from 'node:os';
 import winston from 'winston';
 import { glob } from 'glob';
 import { randomUUID } from 'crypto';
 import { randomUUID as randomUUID$1 } from 'node:crypto';
-import { PklTranscript, readTranscript, listTranscripts as listTranscripts$1 } from '@redaksjon/protokoll-format';
 import * as Cardigantime from '@utilarium/cardigantime';
+import { Storage } from '@google-cloud/storage';
 
 const SCHEME = "protokoll";
 function parseUri(uri) {
@@ -205,7 +208,7 @@ function isProtokolUri(uri) {
   return uri.startsWith(`${SCHEME}://`);
 }
 
-const VERSION = "1.0.21 (HEAD/dd3f7e4 T:v1.0.21 2026-02-25 11:08:34 -0800) linux arm64 v24.14.0";
+const VERSION = "1.0.22-dev.20260227214704.08e3d54 (working/08e3d54  2026-02-27 13:46:39 -0800) linux arm64 v24.14.0";
 const PROGRAM_NAME = "protokoll";
 const DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS = "YYYY-M-D-HHmmss";
 const DEFAULT_AUDIO_EXTENSIONS = ["mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm", "qta"];
@@ -254,8 +257,42 @@ const getSmartAssistanceConfig = (config) => {
 };
 const create = async (options = {}) => {
   const baseInstance = await create$1(options);
+  const resolveEntityByIdentifier = (identifier, directLookup, listAll) => {
+    const normalized = identifier.trim();
+    if (!normalized) {
+      return void 0;
+    }
+    const direct = directLookup(normalized);
+    if (direct) {
+      return direct;
+    }
+    const normalizedLower = normalized.toLowerCase();
+    const uuidPrefix = normalizedLower.match(/^([a-f0-9]{8})/)?.[1];
+    for (const entity of listAll()) {
+      const entityId = entity.id.toLowerCase();
+      const entitySlug = entity.slug?.toLowerCase();
+      if (entityId === normalizedLower) {
+        return entity;
+      }
+      if (entitySlug && entitySlug === normalizedLower) {
+        return entity;
+      }
+      if (entityId.startsWith(normalizedLower) || normalizedLower.startsWith(entityId)) {
+        return entity;
+      }
+      if (uuidPrefix && entityId.startsWith(uuidPrefix)) {
+        return entity;
+      }
+    }
+    return void 0;
+  };
   return {
     ...baseInstance,
+    getPerson: (id) => resolveEntityByIdentifier(id, baseInstance.getPerson, baseInstance.getAllPeople),
+    getProject: (id) => resolveEntityByIdentifier(id, baseInstance.getProject, baseInstance.getAllProjects),
+    getCompany: (id) => resolveEntityByIdentifier(id, baseInstance.getCompany, baseInstance.getAllCompanies),
+    getTerm: (id) => resolveEntityByIdentifier(id, baseInstance.getTerm, baseInstance.getAllTerms),
+    getIgnored: (id) => resolveEntityByIdentifier(id, baseInstance.getIgnored, baseInstance.getAllIgnored),
     getSmartAssistanceConfig: () => getSmartAssistanceConfig(baseInstance.getConfig())
   };
 };
@@ -279,7 +316,270 @@ function fileUriToPath(uri) {
   }
 }
 
+const DEFAULT_STORAGE_CONFIG = {
+  backend: "filesystem"
+};
+
+function normalizePrefix(value) {
+  return value.replace(/^\/+/, "").replace(/\/+/g, "/").replace(/\/+$/, "");
+}
+function parseGcsUri(uri) {
+  if (typeof uri !== "string" || uri.trim().length === 0) {
+    throw new Error("GCS URI must be a non-empty string.");
+  }
+  const trimmed = uri.trim();
+  if (!trimmed.startsWith("gs://")) {
+    throw new Error(`Invalid GCS URI "${uri}": must start with "gs://".`);
+  }
+  const withoutScheme = trimmed.slice("gs://".length);
+  if (withoutScheme.length === 0) {
+    throw new Error(`Invalid GCS URI "${uri}": missing bucket name.`);
+  }
+  const slashIndex = withoutScheme.indexOf("/");
+  const bucket = (slashIndex === -1 ? withoutScheme : withoutScheme.slice(0, slashIndex)).trim();
+  if (bucket.length === 0) {
+    throw new Error(`Invalid GCS URI "${uri}": missing bucket name.`);
+  }
+  const rawPrefix = slashIndex === -1 ? "" : withoutScheme.slice(slashIndex + 1);
+  const prefix = normalizePrefix(rawPrefix);
+  return { bucket, prefix };
+}
+
+const logger$4 = Logging.getLogger("@redaksjon/protokoll-mcp").get("gcs-storage");
+function normalizePath(value) {
+  return value.replace(/^\/+/, "").replace(/\\/g, "/");
+}
+function joinObjectPath(basePrefix, objectPath) {
+  const normalizedBase = basePrefix.replace(/^\/+|\/+$/g, "");
+  const normalizedObjectPath = normalizePath(objectPath);
+  if (!normalizedBase) {
+    return normalizedObjectPath;
+  }
+  if (!normalizedObjectPath) {
+    return normalizedBase;
+  }
+  return `${normalizedBase}/${normalizedObjectPath}`;
+}
+class GcsStorageProvider {
+  constructor(storage, bucketName, basePrefix) {
+    this.storage = storage;
+    this.bucketName = bucketName;
+    this.basePrefix = basePrefix;
+  }
+  name = "gcs";
+  objectPath(pathValue) {
+    return joinObjectPath(this.basePrefix, pathValue);
+  }
+  async readFile(pathValue) {
+    const startedAt = Date.now();
+    const objectPath = this.objectPath(pathValue);
+    logger$4.debug("gcs.read.start", {
+      bucket: this.bucketName,
+      basePrefix: this.basePrefix,
+      path: pathValue,
+      objectPath
+    });
+    const [contents] = await this.storage.bucket(this.bucketName).file(objectPath).download();
+    logger$4.info("gcs.read.complete", {
+      bucket: this.bucketName,
+      objectPath,
+      bytes: contents.length,
+      elapsedMs: Date.now() - startedAt
+    });
+    return contents;
+  }
+  async writeFile(pathValue, data) {
+    const startedAt = Date.now();
+    const objectPath = this.objectPath(pathValue);
+    const bytes = typeof data === "string" ? Buffer.byteLength(data) : data.length;
+    logger$4.debug("gcs.write.start", {
+      bucket: this.bucketName,
+      basePrefix: this.basePrefix,
+      path: pathValue,
+      objectPath,
+      bytes
+    });
+    await this.storage.bucket(this.bucketName).file(objectPath).save(data);
+    logger$4.info("gcs.write.complete", {
+      bucket: this.bucketName,
+      objectPath,
+      bytes,
+      elapsedMs: Date.now() - startedAt
+    });
+  }
+  async listFiles(prefix, pattern) {
+    const startedAt = Date.now();
+    const fullPrefix = this.objectPath(prefix);
+    logger$4.debug("gcs.list.start", {
+      bucket: this.bucketName,
+      basePrefix: this.basePrefix,
+      prefix,
+      fullPrefix,
+      pattern: pattern ?? null
+    });
+    const [files] = await this.storage.bucket(this.bucketName).getFiles({ prefix: fullPrefix });
+    const normalizedBase = this.basePrefix.replace(/^\/+|\/+$/g, "");
+    const relativePaths = files.map((fileRef) => fileRef.name).filter((fileName) => !fileName.endsWith("/")).map((fileName) => {
+      if (!normalizedBase) {
+        return fileName;
+      }
+      const prefixWithSlash = `${normalizedBase}/`;
+      if (fileName.startsWith(prefixWithSlash)) {
+        return fileName.slice(prefixWithSlash.length);
+      }
+      return fileName;
+    });
+    if (!pattern) {
+      logger$4.info("gcs.list.complete", {
+        bucket: this.bucketName,
+        fullPrefix,
+        matchedCount: relativePaths.length,
+        elapsedMs: Date.now() - startedAt
+      });
+      return relativePaths;
+    }
+    const filtered = relativePaths.filter((pathValue) => pathValue.includes(pattern));
+    logger$4.info("gcs.list.complete", {
+      bucket: this.bucketName,
+      fullPrefix,
+      pattern,
+      matchedCount: filtered.length,
+      elapsedMs: Date.now() - startedAt
+    });
+    return filtered;
+  }
+  async deleteFile(pathValue) {
+    const startedAt = Date.now();
+    const objectPath = this.objectPath(pathValue);
+    logger$4.debug("gcs.delete.start", {
+      bucket: this.bucketName,
+      basePrefix: this.basePrefix,
+      path: pathValue,
+      objectPath
+    });
+    await this.storage.bucket(this.bucketName).file(objectPath).delete({ ignoreNotFound: true });
+    logger$4.info("gcs.delete.complete", {
+      bucket: this.bucketName,
+      objectPath,
+      elapsedMs: Date.now() - startedAt
+    });
+  }
+  async exists(pathValue) {
+    const startedAt = Date.now();
+    const objectPath = this.objectPath(pathValue);
+    logger$4.debug("gcs.exists.start", {
+      bucket: this.bucketName,
+      basePrefix: this.basePrefix,
+      path: pathValue,
+      objectPath
+    });
+    const [exists] = await this.storage.bucket(this.bucketName).file(objectPath).exists();
+    logger$4.info("gcs.exists.complete", {
+      bucket: this.bucketName,
+      objectPath,
+      exists,
+      elapsedMs: Date.now() - startedAt
+    });
+    return exists;
+  }
+  async mkdir(_pathValue) {
+  }
+  async verifyBucketAccess() {
+    const startedAt = Date.now();
+    logger$4.debug("gcs.verify_bucket_access.start", {
+      bucket: this.bucketName,
+      basePrefix: this.basePrefix
+    });
+    await this.storage.bucket(this.bucketName).getMetadata();
+    logger$4.info("gcs.verify_bucket_access.complete", {
+      bucket: this.bucketName,
+      elapsedMs: Date.now() - startedAt
+    });
+  }
+}
+function createGcsStorageProvider(uri, credentialsFile, projectId) {
+  const startedAt = Date.now();
+  const { bucket, prefix } = parseGcsUri(uri);
+  logger$4.debug("gcs.provider.create.start", {
+    uri,
+    bucket,
+    prefix,
+    hasCredentialsFile: Boolean(credentialsFile),
+    hasProjectId: Boolean(projectId)
+  });
+  const storage = credentialsFile ? new Storage({ keyFilename: credentialsFile, projectId }) : new Storage({ projectId });
+  logger$4.info("gcs.provider.create.complete", {
+    bucket,
+    prefix,
+    hasCredentialsFile: Boolean(credentialsFile),
+    hasProjectId: Boolean(projectId),
+    elapsedMs: Date.now() - startedAt
+  });
+  return new GcsStorageProvider(storage, bucket, prefix);
+}
+
+async function walkFilesRecursive(directory) {
+  const entries = await readdir(directory, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const absolutePath = join(directory, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await walkFilesRecursive(absolutePath));
+    } else if (entry.isFile()) {
+      files.push(absolutePath);
+    }
+  }
+  return files;
+}
+class FilesystemStorageProvider {
+  constructor(baseDirectory) {
+    this.baseDirectory = baseDirectory;
+  }
+  name = "filesystem";
+  resolvePath(pathValue) {
+    if (isAbsolute(pathValue)) {
+      return pathValue;
+    }
+    return resolve(this.baseDirectory, pathValue);
+  }
+  toRelativePath(pathValue) {
+    return relative(this.baseDirectory, pathValue);
+  }
+  async readFile(pathValue) {
+    return readFile(this.resolvePath(pathValue));
+  }
+  async writeFile(pathValue, data) {
+    const resolvedPath = this.resolvePath(pathValue);
+    await mkdir(dirname(resolvedPath), { recursive: true });
+    await writeFile(resolvedPath, data);
+  }
+  async listFiles(prefix, pattern) {
+    const prefixPath = this.resolvePath(prefix || ".");
+    const allFiles = await walkFilesRecursive(prefixPath);
+    const relativeFiles = allFiles.map((filePath) => this.toRelativePath(filePath));
+    if (!pattern) {
+      return relativeFiles;
+    }
+    return relativeFiles.filter((filePath) => filePath.includes(pattern));
+  }
+  async deleteFile(pathValue) {
+    await rm(this.resolvePath(pathValue), { force: true });
+  }
+  async exists(pathValue) {
+    try {
+      await stat(this.resolvePath(pathValue));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async mkdir(pathValue) {
+    await mkdir(this.resolvePath(pathValue), { recursive: true });
+  }
+}
+
 const DEFAULT_CONFIG_FILE$1 = "protokoll-config.yaml";
+const logger$3 = Logging.getLogger("@redaksjon/protokoll-mcp").get("server-config");
 const cardigantime = Cardigantime.create({
   defaults: {
     configDirectory: ".",
@@ -290,7 +590,7 @@ const cardigantime = Cardigantime.create({
     // pathFields determines which fields are processed, resolvePathArray determines
     // if array elements should be resolved individually
     pathResolution: {
-      pathFields: ["inputDirectory", "outputDirectory", "processedDirectory", "contextDirectories"],
+      pathFields: ["inputDirectory", "outputDirectory", "processedDirectory", "contextDirectories", "storage.gcs.credentialsFile"],
       resolvePathArray: ["contextDirectories"]
     }
   },
@@ -301,11 +601,79 @@ async function readConfigFromDirectory(directory) {
   const previousCwd = process.cwd();
   try {
     process.chdir(directory);
-    return await cardigantime.read({});
+    const discoveredConfig = await cardigantime.read({});
+    return mergeConfigWithEnv(discoveredConfig);
   } finally {
     process.chdir(previousCwd);
   }
 }
+function parseBooleanEnv(value) {
+  if (!value) return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true") return true;
+  if (normalized === "false") return false;
+  return void 0;
+}
+function parseCsvEnv(value) {
+  if (!value) return void 0;
+  const parsed = value.split(",").map((part) => part.trim()).filter(Boolean);
+  return parsed.length > 0 ? parsed : void 0;
+}
+function readEnvString(name) {
+  return readString(process.env[name]);
+}
+function mergeNestedObjects(base, overrides) {
+  const merged = { ...base };
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value === void 0) continue;
+    const existing = merged[key];
+    if (isObjectRecord(existing) && isObjectRecord(value)) {
+      merged[key] = mergeNestedObjects(existing, value);
+      continue;
+    }
+    merged[key] = value;
+  }
+  return merged;
+}
+function buildEnvStorageConfig() {
+  const configuredBackend = readEnvString("PROTOKOLL_STORAGE_BACKEND");
+  const gcs = {
+    projectId: readEnvString("PROTOKOLL_STORAGE_GCS_PROJECT_ID"),
+    inputUri: readEnvString("PROTOKOLL_STORAGE_GCS_INPUT_URI"),
+    outputUri: readEnvString("PROTOKOLL_STORAGE_GCS_OUTPUT_URI"),
+    contextUri: readEnvString("PROTOKOLL_STORAGE_GCS_CONTEXT_URI"),
+    inputBucket: readEnvString("PROTOKOLL_STORAGE_GCS_INPUT_BUCKET"),
+    inputPrefix: readEnvString("PROTOKOLL_STORAGE_GCS_INPUT_PREFIX"),
+    outputBucket: readEnvString("PROTOKOLL_STORAGE_GCS_OUTPUT_BUCKET"),
+    outputPrefix: readEnvString("PROTOKOLL_STORAGE_GCS_OUTPUT_PREFIX"),
+    contextBucket: readEnvString("PROTOKOLL_STORAGE_GCS_CONTEXT_BUCKET"),
+    contextPrefix: readEnvString("PROTOKOLL_STORAGE_GCS_CONTEXT_PREFIX"),
+    credentialsFile: readEnvString("PROTOKOLL_STORAGE_GCS_CREDENTIALS_FILE")
+  };
+  const hasGcsValue = Object.values(gcs).some((value) => value !== void 0);
+  const backend = configuredBackend ?? (hasGcsValue ? "gcs" : void 0);
+  if (!backend) return void 0;
+  const storage = {};
+  if (backend) storage.backend = backend;
+  if (hasGcsValue) storage.gcs = gcs;
+  return storage;
+}
+function mergeConfigWithEnv(config) {
+  const envOverrides = {
+    inputDirectory: readEnvString("PROTOKOLL_INPUT_DIRECTORY"),
+    outputDirectory: readEnvString("PROTOKOLL_OUTPUT_DIRECTORY"),
+    processedDirectory: readEnvString("PROTOKOLL_PROCESSED_DIRECTORY"),
+    contextDirectories: parseCsvEnv(process.env.PROTOKOLL_CONTEXT_DIRECTORIES),
+    model: readEnvString("PROTOKOLL_MODEL"),
+    classifyModel: readEnvString("PROTOKOLL_CLASSIFY_MODEL"),
+    composeModel: readEnvString("PROTOKOLL_COMPOSE_MODEL"),
+    transcriptionModel: readEnvString("PROTOKOLL_TRANSCRIPTION_MODEL"),
+    debug: parseBooleanEnv(process.env.PROTOKOLL_DEBUG),
+    verbose: parseBooleanEnv(process.env.PROTOKOLL_VERBOSE),
+    storage: buildEnvStorageConfig()
+  };
+  return mergeNestedObjects(config, envOverrides);
+}
 let serverConfig = {
   mode: "local",
   context: null,
@@ -313,10 +681,163 @@ let serverConfig = {
   inputDirectory: null,
   outputDirectory: null,
   processedDirectory: null,
+  inputStorage: null,
+  outputStorage: null,
+  storageConfig: DEFAULT_STORAGE_CONFIG,
   configFilePath: null,
   configFile: null,
   initialized: false
 };
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function buildGcsUri(bucket, prefix) {
+  const trimmedBucket = bucket.trim();
+  const normalizedPrefix = (prefix ?? "").replace(/^\/+/, "").replace(/\/+/g, "/").replace(/\/+$/, "");
+  if (!normalizedPrefix) {
+    return `gs://${trimmedBucket}`;
+  }
+  return `gs://${trimmedBucket}/${normalizedPrefix}`;
+}
+function resolveGcsUri(rawUri, bucket, prefix) {
+  if (bucket) {
+    return buildGcsUri(bucket, prefix);
+  }
+  return rawUri ?? "";
+}
+function resolveGcsUris(gcs) {
+  return {
+    inputUri: resolveGcsUri(gcs.inputUri, gcs.inputBucket, gcs.inputPrefix),
+    outputUri: resolveGcsUri(gcs.outputUri, gcs.outputBucket, gcs.outputPrefix),
+    contextUri: resolveGcsUri(gcs.contextUri, gcs.contextBucket, gcs.contextPrefix)
+  };
+}
+function parseStorageConfig(configFile) {
+  if (!configFile) {
+    return DEFAULT_STORAGE_CONFIG;
+  }
+  const rawStorage = configFile.storage;
+  if (!isObjectRecord(rawStorage)) {
+    return DEFAULT_STORAGE_CONFIG;
+  }
+  const backend = rawStorage.backend === "gcs" ? "gcs" : "filesystem";
+  if (backend !== "gcs") {
+    return DEFAULT_STORAGE_CONFIG;
+  }
+  const rawGcs = isObjectRecord(rawStorage.gcs) ? rawStorage.gcs : {};
+  const projectId = readString(rawGcs.projectId);
+  const inputUri = readString(rawGcs.inputUri);
+  const outputUri = readString(rawGcs.outputUri);
+  const contextUri = readString(rawGcs.contextUri);
+  const inputBucket = readString(rawGcs.inputBucket);
+  const inputPrefix = readString(rawGcs.inputPrefix);
+  const outputBucket = readString(rawGcs.outputBucket);
+  const outputPrefix = readString(rawGcs.outputPrefix);
+  const contextBucket = readString(rawGcs.contextBucket);
+  const contextPrefix = readString(rawGcs.contextPrefix);
+  const credentialsFile = readString(rawGcs.credentialsFile);
+  return {
+    backend: "gcs",
+    gcs: {
+      projectId,
+      inputUri,
+      outputUri,
+      contextUri,
+      inputBucket,
+      inputPrefix,
+      outputBucket,
+      outputPrefix,
+      contextBucket,
+      contextPrefix,
+      credentialsFile
+    }
+  };
+}
+function resolveCredentialsFilePath(credentialsFile, configDir) {
+  if (!credentialsFile || credentialsFile.trim().length === 0) {
+    return void 0;
+  }
+  return resolve(configDir, credentialsFile);
+}
+async function validateGcsStorageConfig(storageConfig, configDir) {
+  if (storageConfig.backend !== "gcs") {
+    return void 0;
+  }
+  if (!storageConfig.gcs) {
+    throw new Error("storage.backend is set to gcs, but storage.gcs is missing.");
+  }
+  const startedAt = Date.now();
+  const { inputUri, outputUri, contextUri } = resolveGcsUris(storageConfig.gcs);
+  logger$3.debug("storage.gcs.validate.start", {
+    configDir,
+    inputUri,
+    outputUri,
+    contextUri,
+    projectId: storageConfig.gcs.projectId ?? null,
+    hasCredentialsFile: Boolean(storageConfig.gcs.credentialsFile)
+  });
+  if (!inputUri || !outputUri || !contextUri) {
+    throw new Error(
+      "GCS config is incomplete. Provide either storage.gcs.{inputUri,outputUri,contextUri} or storage.gcs.{inputBucket,inputPrefix,outputBucket,outputPrefix,contextBucket,contextPrefix}."
+    );
+  }
+  parseGcsUri(inputUri);
+  parseGcsUri(outputUri);
+  parseGcsUri(contextUri);
+  const credentialsFile = resolveCredentialsFilePath(storageConfig.gcs.credentialsFile, configDir);
+  if (credentialsFile) {
+    try {
+      await access(credentialsFile);
+    } catch {
+      throw new Error(`GCS credentials file is not readable: ${credentialsFile}`);
+    }
+  }
+  logger$3.info("storage.gcs.validate.complete", {
+    inputUri,
+    outputUri,
+    contextUri,
+    projectId: storageConfig.gcs.projectId ?? null,
+    credentialsFile: credentialsFile ?? null,
+    elapsedMs: Date.now() - startedAt
+  });
+  return credentialsFile;
+}
+async function createStorageProviders(storageConfig, inputDirectory, outputDirectory, configDir) {
+  if (storageConfig.backend === "filesystem") {
+    return {
+      inputStorage: new FilesystemStorageProvider(inputDirectory),
+      outputStorage: new FilesystemStorageProvider(outputDirectory)
+    };
+  }
+  if (!storageConfig.gcs) {
+    throw new Error("storage.backend is set to gcs, but storage.gcs is missing.");
+  }
+  const startedAt = Date.now();
+  const { inputUri, outputUri } = resolveGcsUris(storageConfig.gcs);
+  logger$3.debug("storage.providers.gcs.start", {
+    inputUri,
+    outputUri,
+    projectId: storageConfig.gcs.projectId ?? null
+  });
+  const credentialsFile = await validateGcsStorageConfig(storageConfig, configDir);
+  const inputStorage = createGcsStorageProvider(inputUri, credentialsFile, storageConfig.gcs.projectId);
+  const outputStorage = createGcsStorageProvider(outputUri, credentialsFile, storageConfig.gcs.projectId);
+  await inputStorage.verifyBucketAccess();
+  await outputStorage.verifyBucketAccess();
+  logger$3.info("storage.providers.gcs.complete", {
+    inputUri,
+    outputUri,
+    projectId: storageConfig.gcs.projectId ?? null,
+    elapsedMs: Date.now() - startedAt
+  });
+  return {
+    inputStorage,
+    outputStorage
+  };
+}
 async function initializeServerConfig(roots, mode = "local") {
   const workspaceRoot = roots.length > 0 ? fileUriToPath(roots[0].uri) : null;
   if (!workspaceRoot) {
@@ -327,6 +848,9 @@ async function initializeServerConfig(roots, mode = "local") {
       inputDirectory: resolve(process.cwd(), "./recordings"),
       outputDirectory: resolve(process.cwd(), "./notes"),
       processedDirectory: resolve(process.cwd(), "./processed"),
+      inputStorage: new FilesystemStorageProvider(resolve(process.cwd(), "./recordings")),
+      outputStorage: new FilesystemStorageProvider(resolve(process.cwd(), "./notes")),
+      storageConfig: DEFAULT_STORAGE_CONFIG,
       configFilePath: null,
       configFile: null,
       initialized: true
@@ -339,23 +863,45 @@ async function initializeServerConfig(roots, mode = "local") {
     const configFilePath = Array.isArray(resolvedConfigDirs) && resolvedConfigDirs.length > 0 ? resolve(resolvedConfigDirs[0], DEFAULT_CONFIG_FILE$1) : null;
     const configDir = Array.isArray(resolvedConfigDirs) && resolvedConfigDirs.length > 0 ? resolvedConfigDirs[0] : workspaceRoot;
     const resolvedContextDirs = configFile.contextDirectories;
-    const context = await create({
+    const contextCreateOptions = {
       startingDir: workspaceRoot,
       contextDirectories: resolvedContextDirs
-    });
+    };
+    const storageConfig = parseStorageConfig(configFile);
+    const credentialsFile = await validateGcsStorageConfig(storageConfig, configDir);
+    if (storageConfig.backend === "gcs" && storageConfig.gcs) {
+      if (storageConfig.gcs.projectId) {
+        process.env.GOOGLE_CLOUD_PROJECT = storageConfig.gcs.projectId;
+      }
+      const { contextUri } = resolveGcsUris(storageConfig.gcs);
+      const parsedContextUri = parseGcsUri(contextUri);
+      contextCreateOptions.gcs = {
+        bucketName: parsedContextUri.bucket,
+        basePath: parsedContextUri.prefix,
+        credentialsFile
+      };
+      delete contextCreateOptions.contextDirectories;
+    }
+    const context = await create(contextCreateOptions);
     const contextConfig = context.getConfig();
     const mergedConfig = {
       ...contextConfig,
       ...configFile
     };
+    const inputDirectory = mergedConfig.inputDirectory || resolve(configDir, "./recordings");
+    const outputDirectory = mergedConfig.outputDirectory || resolve(configDir, "./notes");
+    const { inputStorage, outputStorage } = await createStorageProviders(storageConfig, inputDirectory, outputDirectory, configDir);
     serverConfig = {
       mode,
       context,
       workspaceRoot,
       // CardiganTime already resolved these paths; just provide defaults if not set
-      inputDirectory: mergedConfig.inputDirectory || resolve(configDir, "./recordings"),
-      outputDirectory: mergedConfig.outputDirectory || resolve(configDir, "./notes"),
+      inputDirectory,
+      outputDirectory,
       processedDirectory: mergedConfig.processedDirectory || resolve(configDir, "./processed"),
+      inputStorage,
+      outputStorage,
+      storageConfig,
       configFilePath,
       configFile: configFile ?? null,
       initialized: true
@@ -366,14 +912,21 @@ async function initializeServerConfig(roots, mode = "local") {
     const configFilePath = Array.isArray(resolvedConfigDirs) && resolvedConfigDirs.length > 0 ? resolve(resolvedConfigDirs[0], DEFAULT_CONFIG_FILE$1) : null;
     const configDir = Array.isArray(resolvedConfigDirs) && resolvedConfigDirs.length > 0 ? resolvedConfigDirs[0] : workspaceRoot;
     const mergedConfig = configFile ?? {};
+    const storageConfig = parseStorageConfig(configFile);
+    const inputDirectory = mergedConfig.inputDirectory || resolve(configDir, "./recordings");
+    const outputDirectory = mergedConfig.outputDirectory || resolve(configDir, "./notes");
+    const { inputStorage, outputStorage } = await createStorageProviders(storageConfig, inputDirectory, outputDirectory, configDir);
     serverConfig = {
       mode,
       context: null,
       workspaceRoot,
       // CardiganTime already resolved these paths; just provide defaults if not set
-      inputDirectory: mergedConfig.inputDirectory || resolve(configDir, "./recordings"),
-      outputDirectory: mergedConfig.outputDirectory || resolve(configDir, "./notes"),
+      inputDirectory,
+      outputDirectory,
       processedDirectory: mergedConfig.processedDirectory || resolve(configDir, "./processed"),
+      inputStorage,
+      outputStorage,
+      storageConfig,
       configFilePath,
       configFile: configFile ?? null,
       initialized: true
@@ -391,6 +944,9 @@ function clearServerConfig() {
     inputDirectory: null,
     outputDirectory: null,
     processedDirectory: null,
+    inputStorage: null,
+    outputStorage: null,
+    storageConfig: DEFAULT_STORAGE_CONFIG,
     configFilePath: null,
     configFile: null,
     initialized: false
@@ -407,6 +963,7 @@ function getServerConfig() {
     inputDirectory: serverConfig.inputDirectory,
     outputDirectory: serverConfig.outputDirectory,
     processedDirectory: serverConfig.processedDirectory,
+    storageConfig: serverConfig.storageConfig,
     configFilePath: serverConfig.configFilePath,
     configFile: serverConfig.configFile,
     initialized: serverConfig.initialized
@@ -436,6 +993,21 @@ function getProcessedDirectory() {
   }
   return serverConfig.processedDirectory;
 }
+function getStorageConfig() {
+  return serverConfig.storageConfig;
+}
+function getInputStorage() {
+  if (!serverConfig.initialized || !serverConfig.inputStorage) {
+    return new FilesystemStorageProvider(resolve(process.cwd(), "./recordings"));
+  }
+  return serverConfig.inputStorage;
+}
+function getOutputStorage() {
+  if (!serverConfig.initialized || !serverConfig.outputStorage) {
+    return new FilesystemStorageProvider(resolve(process.cwd(), "./notes"));
+  }
+  return serverConfig.outputStorage;
+}
 function isInitialized() {
   return serverConfig.initialized;
 }
@@ -451,10 +1023,13 @@ const serverConfig$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProp
     clearServerConfig,
     getContext,
     getInputDirectory,
+    getInputStorage,
     getOutputDirectory,
+    getOutputStorage,
     getProcessedDirectory,
     getServerConfig,
     getServerMode,
+    getStorageConfig,
     getWorkspaceRoot: getWorkspaceRoot$2,
     initializeServerConfig,
     isInitialized,
@@ -684,8 +1259,8 @@ const createLogger = (level = "info") => {
     transports
   });
 };
-let logger$1 = createLogger();
-const getLogger = () => logger$1;
+let logger$2 = createLogger();
+const getLogger = () => logger$2;
 
 const transcriptExists$1 = Transcript.transcriptExists;
 const ensurePklExtension$1 = Transcript.ensurePklExtension;
@@ -695,9 +1270,9 @@ function isUuidInput(input) {
 async function findTranscriptByUuid$1(uuid, searchDirectories) {
   return Transcript.findTranscriptByUuid(uuid, searchDirectories);
 }
-const logger = getLogger();
-const media = Media.create(logger);
-const storage = Util.create({ log: logger.debug.bind(logger) });
+const logger$1 = getLogger();
+const media = Media.create(logger$1);
+const storage = Util.create({ log: logger$1.debug.bind(logger$1) });
 async function fileExists(path) {
   try {
     await stat(path);
@@ -724,10 +1299,30 @@ async function getContextDirectories() {
 }
 async function createToolContext(contextDirectory) {
   const ServerConfig = await Promise.resolve().then(() => serverConfig$1);
+  const serverContext = ServerConfig.getContext();
+  if (serverContext?.hasContext()) {
+    return serverContext;
+  }
   const configFile = ServerConfig.isInitialized() ? ServerConfig.getServerConfig().configFile : null;
   const rawDirs = configFile?.contextDirectories;
   const effectiveDir = contextDirectory || (ServerConfig.isInitialized() ? ServerConfig.getWorkspaceRoot() : null) || process.cwd();
   const contextDirs = rawDirs && rawDirs.length > 0 ? rawDirs.map((d) => isAbsolute(d) ? d : resolve(effectiveDir, d)) : void 0;
+  const storageConfig = ServerConfig.getStorageConfig();
+  if (storageConfig.backend === "gcs" && storageConfig.gcs) {
+    const contextUri = storageConfig.gcs.contextUri || (storageConfig.gcs.contextBucket ? `gs://${storageConfig.gcs.contextBucket}/${(storageConfig.gcs.contextPrefix || "").replace(/^\/+|\/+$/g, "")}` : void 0);
+    if (!contextUri) {
+      throw new Error("GCS storage is enabled but context URI/bucket configuration is missing.");
+    }
+    const parsedContextUri = parseGcsUri(contextUri);
+    return create({
+      startingDir: effectiveDir,
+      gcs: {
+        bucketName: parsedContextUri.bucket,
+        basePath: parsedContextUri.prefix,
+        credentialsFile: storageConfig.gcs.credentialsFile
+      }
+    });
+  }
   return create({
     startingDir: effectiveDir,
     contextDirectories: contextDirs
@@ -901,7 +1496,7 @@ const shared = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     getAudioMetadata,
     getConfiguredDirectory,
     getContextDirectories,
-    logger,
+    logger: logger$1,
     media,
     mergeArray,
     resolveTranscriptPath: resolveTranscriptPath$1,
@@ -914,6 +1509,7 @@ const shared = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const { listTranscripts, resolveTranscriptPath, readTranscriptContent, stripTranscriptExtension } = Transcript;
+const logger = Logging.getLogger("@redaksjon/protokoll-mcp").get("transcript-resources");
 function parseStoredSummaries$1(raw) {
   try {
     const parsed = JSON.parse(raw);
@@ -950,6 +1546,13 @@ async function readTranscriptResource(transcriptPath) {
     throw new Error(`Invalid transcript path: ${transcriptPath}`);
   }
   const outputDirectory = getOutputDirectory();
+  const outputStorage = getOutputStorage();
+  if (outputStorage.name === "gcs") {
+    const gcsResult = await readTranscriptResourceFromStorage(transcriptPath, outputStorage, outputDirectory);
+    if (gcsResult) {
+      return gcsResult;
+    }
+  }
   const basePath = transcriptPath.startsWith("/") ? transcriptPath : resolve(outputDirectory, transcriptPath);
   const resolved = await resolveTranscriptPath(basePath);
   if (!resolved.exists || !resolved.path) {
@@ -957,7 +1560,6 @@ async function readTranscriptResource(transcriptPath) {
   }
   try {
     const { content, metadata, title } = await readTranscriptContent(resolved.path);
-    const { PklTranscript } = await import('@redaksjon/protokoll-format');
     const pklTranscript = PklTranscript.open(resolved.path, { readOnly: true });
     let rawTranscript = void 0;
     let summaries = [];
@@ -1016,9 +1618,245 @@ async function readTranscriptResource(transcriptPath) {
     throw error;
   }
 }
+async function withTempPklFile(contents, action) {
+  const tempPath = `${tmpdir()}/protokoll-mcp-${Date.now()}-${Math.random().toString(36).slice(2)}.pkl`;
+  await fs.writeFile(tempPath, contents);
+  try {
+    return await action(tempPath);
+  } finally {
+    await fs.rm(tempPath, { force: true });
+  }
+}
+async function resolveStorageTranscriptPath(transcriptPath, outputStorage) {
+  const candidates = /* @__PURE__ */ new Set();
+  const normalizedInput = transcriptPath.replace(/^\/+/, "").replace(/\\/g, "/");
+  if (normalizedInput.length > 0) {
+    candidates.add(normalizedInput);
+  }
+  if (!normalizedInput.toLowerCase().endsWith(".pkl")) {
+    candidates.add(`${normalizedInput}.pkl`);
+  }
+  for (const candidate of candidates) {
+    if (await outputStorage.exists(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+async function readTranscriptResourceFromStorage(transcriptPath, outputStorage, outputDirectory) {
+  const storagePath = await resolveStorageTranscriptPath(transcriptPath, outputStorage);
+  if (!storagePath) {
+    return null;
+  }
+  const contents = await outputStorage.readFile(storagePath);
+  return withTempPklFile(contents, async (tempPath) => {
+    const { content, metadata, title } = await readTranscriptContent(tempPath);
+    const pklTranscript = PklTranscript.open(tempPath, { readOnly: true });
+    let rawTranscript = void 0;
+    let summaries = [];
+    try {
+      if (pklTranscript.hasRawTranscript) {
+        const rawData = pklTranscript.rawTranscript;
+        if (rawData) {
+          rawTranscript = {
+            text: rawData.text,
+            model: rawData.model,
+            duration: rawData.duration,
+            transcribedAt: rawData.transcribedAt
+          };
+        }
+      }
+      const historyArtifact = pklTranscript.getArtifact("summary_history");
+      summaries = parseStoredSummaries$1(historyArtifact?.data?.toString("utf8") || "[]");
+    } finally {
+      pklTranscript.close();
+    }
+    const safeRelativePath = await sanitizePath(storagePath, outputDirectory);
+    const identifierPath = stripTranscriptExtension(safeRelativePath);
+    const structuredResponse = {
+      uri: buildTranscriptUri(identifierPath),
+      path: identifierPath,
+      title: title || basename(identifierPath) || "Untitled",
+      metadata: {
+        date: metadata.date,
+        time: metadata.time,
+        project: metadata.project,
+        projectId: metadata.projectId,
+        status: metadata.status,
+        tags: metadata.tags || [],
+        duration: metadata.duration,
+        entities: metadata.entities || {},
+        tasks: metadata.tasks || [],
+        history: metadata.history || [],
+        routing: metadata.destination ? {
+          destination: metadata.destination,
+          confidence: metadata.confidence
+        } : void 0
+      },
+      content,
+      rawTranscript,
+      summaries
+    };
+    return {
+      uri: buildTranscriptUri(identifierPath),
+      mimeType: "application/json",
+      text: JSON.stringify(structuredResponse)
+    };
+  });
+}
+function normalizeDateOnly(value) {
+  if (!value) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  return trimmed.includes("T") ? trimmed.slice(0, 10) : trimmed;
+}
+function asOptionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function passesDateFilter(date, startDate, endDate) {
+  const normalized = normalizeDateOnly(date);
+  if (!normalized) {
+    return !startDate && !endDate;
+  }
+  if (startDate && normalized < startDate) {
+    return false;
+  }
+  if (endDate && normalized > endDate) {
+    return false;
+  }
+  return true;
+}
+async function listTranscriptsFromStorage(options) {
+  const startedAt = Date.now();
+  const {
+    outputStorage,
+    outputDirectory,
+    startDate,
+    endDate,
+    projectId,
+    projectName,
+    limit,
+    offset
+  } = options;
+  logger.info("transcripts.gcs.list.start", {
+    directory: outputDirectory,
+    limit,
+    offset,
+    startDate: startDate ?? null,
+    endDate: endDate ?? null,
+    projectId: projectId ?? null,
+    projectName: projectName ?? null
+  });
+  const listStartedAt = Date.now();
+  const allFiles = await outputStorage.listFiles("");
+  logger.info("transcripts.gcs.list.objects_loaded", {
+    totalObjects: allFiles.length,
+    elapsedMs: Date.now() - listStartedAt
+  });
+  const transcriptCandidates = allFiles.filter((pathValue) => {
+    const normalized = pathValue.replace(/\\/g, "/").toLowerCase();
+    return normalized.endsWith(".pkl") && !normalized.startsWith("uploads/") && !normalized.startsWith(".intermediate/") && !normalized.includes("/uploads/") && !normalized.includes("/.intermediate/");
+  });
+  logger.info("transcripts.gcs.list.transcript_candidates", {
+    candidates: transcriptCandidates.length,
+    ignoredObjects: allFiles.length - transcriptCandidates.length
+  });
+  let processedCandidates = 0;
+  const hydrateStartedAt = Date.now();
+  const hydrated = await Promise.all(
+    transcriptCandidates.map(async (pathValue) => {
+      try {
+        const buffer = await outputStorage.readFile(pathValue);
+        const hydratedEntry = await withTempPklFile(buffer, async (tempPath) => {
+          const { content, metadata, title } = await readTranscriptContent(tempPath);
+          const pklTranscript = PklTranscript.open(tempPath, { readOnly: true });
+          let hasRawTranscript = false;
+          try {
+            hasRawTranscript = Boolean(pklTranscript.hasRawTranscript);
+          } finally {
+            pklTranscript.close();
+          }
+          const metadataProjectId = asOptionalString(metadata.projectId);
+          const metadataProject = asOptionalString(metadata.project);
+          if (projectId) {
+            const projectMatches = metadataProjectId === projectId || (projectName ? metadataProject === projectName : metadataProject === projectId);
+            if (!projectMatches) {
+              return null;
+            }
+          }
+          const transcriptDate = normalizeDateOnly(asOptionalString(metadata.date));
+          if (!passesDateFilter(transcriptDate, startDate, endDate)) {
+            return null;
+          }
+          const safePath = await sanitizePath(pathValue, outputDirectory);
+          return {
+            path: safePath,
+            filename: basename(pathValue),
+            date: transcriptDate || "1970-01-01",
+            time: asOptionalString(metadata.time),
+            title: title || stripTranscriptExtension(basename(pathValue)),
+            status: asOptionalString(metadata.status),
+            openTasksCount: Array.isArray(metadata.tasks) ? metadata.tasks.filter((task) => {
+              if (!task || typeof task !== "object") {
+                return true;
+              }
+              return task.status !== "completed";
+            }).length : 0,
+            contentSize: content.length,
+            entities: metadata.entities,
+            hasRawTranscript
+          };
+        });
+        return hydratedEntry;
+      } catch {
+        return null;
+      } finally {
+        processedCandidates++;
+        if (processedCandidates % 25 === 0 || processedCandidates === transcriptCandidates.length) {
+          logger.info("transcripts.gcs.list.progress", {
+            processed: processedCandidates,
+            total: transcriptCandidates.length,
+            elapsedMs: Date.now() - hydrateStartedAt
+          });
+        }
+      }
+    })
+  );
+  const filtered = hydrated.filter((item) => item !== null).sort((a, b) => {
+    const dateCompare = b.date.localeCompare(a.date);
+    if (dateCompare !== 0) {
+      return dateCompare;
+    }
+    const timeCompare = (b.time || "").localeCompare(a.time || "");
+    if (timeCompare !== 0) {
+      return timeCompare;
+    }
+    return b.filename.localeCompare(a.filename);
+  });
+  const page = filtered.slice(offset, offset + limit);
+  logger.info("transcripts.gcs.list.complete", {
+    totalCandidates: transcriptCandidates.length,
+    totalAfterFilters: filtered.length,
+    returned: page.length,
+    hasMore: offset + limit < filtered.length,
+    elapsedMs: Date.now() - startedAt
+  });
+  return {
+    transcripts: page,
+    total: filtered.length,
+    hasMore: offset + limit < filtered.length,
+    limit,
+    offset
+  };
+}
 async function readTranscriptsListResource(options) {
   const { startDate, endDate, limit = 50, offset = 0, projectId } = options;
   const outputDirectory = getOutputDirectory();
+  const outputStorage = getOutputStorage();
   const directory = options.directory || outputDirectory;
   let projectName;
   if (projectId && isInitialized()) {
@@ -1041,7 +1879,16 @@ async function readTranscriptsListResource(options) {
     console.log(`   Date range: ${startDate || "any"} to ${endDate || "any"}`);
   }
   console.log(`   Limit: ${limit}, Offset: ${offset}`);
-  const result = await listTranscripts({
+  const result = outputStorage.name === "gcs" ? await listTranscriptsFromStorage({
+    outputStorage,
+    outputDirectory,
+    startDate,
+    endDate,
+    projectId,
+    projectName,
+    limit,
+    offset
+  }) : await listTranscripts({
     directory,
     limit,
     offset,
@@ -1105,16 +1952,90 @@ async function readTranscriptsListResource(options) {
   };
 }
 
+const ENTITY_DIRECTORY = {
+  person: "people",
+  project: "projects",
+  term: "terms",
+  company: "companies",
+  ignored: "ignored"
+};
+function buildContextGcsUri() {
+  const storageConfig = getStorageConfig();
+  if (storageConfig.backend !== "gcs" || !storageConfig.gcs) {
+    return null;
+  }
+  const gcs = storageConfig.gcs;
+  const contextUri = gcs.contextUri || (gcs.contextBucket ? `gs://${gcs.contextBucket}/${(gcs.contextPrefix || "").replace(/^\/+|\/+$/g, "")}` : void 0);
+  if (!contextUri) {
+    return null;
+  }
+  return {
+    uri: contextUri,
+    projectId: gcs.projectId,
+    credentialsFile: gcs.credentialsFile
+  };
+}
+async function loadEntitiesFromGcs(entityType) {
+  const contextGcs = buildContextGcsUri();
+  if (!contextGcs) {
+    return [];
+  }
+  const provider = createGcsStorageProvider(contextGcs.uri, contextGcs.credentialsFile, contextGcs.projectId);
+  const directory = ENTITY_DIRECTORY[entityType];
+  const files = await provider.listFiles(`${directory}/`);
+  const yamlFiles = files.filter((pathValue) => pathValue.endsWith(".yaml") || pathValue.endsWith(".yml"));
+  const entities = [];
+  for (const filePath of yamlFiles) {
+    try {
+      const raw = await provider.readFile(filePath);
+      const parsed = yaml.load(raw.toString("utf8"));
+      if (parsed && typeof parsed === "object") {
+        entities.push(parsed);
+      }
+    } catch {
+    }
+  }
+  return entities;
+}
+async function findEntityInGcs(entityType, entityId) {
+  const entities = await loadEntitiesFromGcs(entityType);
+  const normalized = entityId.trim().toLowerCase();
+  const prefix = normalized.match(/^([a-f0-9]{8})/)?.[1];
+  for (const entity of entities) {
+    const id = typeof entity.id === "string" ? entity.id : "";
+    const slug = typeof entity.slug === "string" ? entity.slug : "";
+    const idLower = id.toLowerCase();
+    const slugLower = slug.toLowerCase();
+    if (idLower === normalized || slugLower === normalized) {
+      return entity;
+    }
+    if (normalized && (idLower.startsWith(normalized) || normalized.startsWith(idLower))) {
+      return entity;
+    }
+    if (prefix && idLower.startsWith(prefix)) {
+      return entity;
+    }
+  }
+  return null;
+}
 async function readEntityResource(entityType, entityId, contextDirectory) {
-  const configFile = isInitialized() ? getServerConfig().configFile : null;
-  const rawDirs = configFile?.contextDirectories;
+  if (entityType in ENTITY_DIRECTORY && isInitialized()) {
+    const storageConfig = getStorageConfig();
+    if (storageConfig.backend === "gcs") {
+      const gcsEntity = await findEntityInGcs(entityType, entityId);
+      if (gcsEntity) {
+        const yamlContent2 = yaml.dump(gcsEntity);
+        return {
+          uri: buildEntityUri(entityType, entityId),
+          mimeType: "application/yaml",
+          text: yamlContent2
+        };
+      }
+    }
+  }
   const effectiveDir = contextDirectory || getWorkspaceRoot$2() || process.cwd();
-  const contextDirs = rawDirs && rawDirs.length > 0 ? rawDirs.map((d) => isAbsolute(d) ? d : resolve(effectiveDir, d)) : void 0;
-  console.log(`   [entity] Looking up ${entityType}/${entityId} (fresh context from ${effectiveDir})`);
-  const context = await create({
-    startingDir: effectiveDir,
-    contextDirectories: contextDirs
-  });
+  console.log(`   [entity] Looking up ${entityType}/${entityId} (context from ${effectiveDir})`);
+  const context = await createToolContext(contextDirectory);
   if (!context.hasContext()) {
     const searchDir = contextDirectory || process.cwd();
     console.log(`   [entity] ❌ No Protokoll context found in ${searchDir}`);
@@ -1154,6 +2075,32 @@ async function readEntityResource(entityType, entityId, contextDirectory) {
   };
 }
 async function readEntitiesListResource(entityType, contextDirectory) {
+  if (entityType in ENTITY_DIRECTORY && isInitialized()) {
+    const storageConfig = getStorageConfig();
+    if (storageConfig.backend === "gcs") {
+      const entitiesFromGcs = await loadEntitiesFromGcs(entityType);
+      const entities2 = entitiesFromGcs.map((entity) => {
+        const id = String(entity.id || "");
+        const name = String(entity.name || "");
+        return {
+          uri: buildEntityUri(entityType, id),
+          id,
+          name,
+          ...entity
+        };
+      });
+      const responseData2 = {
+        entityType,
+        count: entities2.length,
+        entities: entities2
+      };
+      return {
+        uri: buildEntitiesListUri(entityType),
+        mimeType: "application/json",
+        text: JSON.stringify(responseData2, null, 2)
+      };
+    }
+  }
   let context;
   if (isInitialized()) {
     const serverContext = getContext();
@@ -2334,17 +3281,17 @@ async function findAudioFile(filenameOrPath) {
   if (filenameOrPath.startsWith("/") && await fileExists(filenameOrPath)) {
     return filenameOrPath;
   }
+  const ServerConfig = await Promise.resolve().then(() => serverConfig$1);
+  const inputStorage = ServerConfig.getInputStorage();
   const inputDirectory = await getConfiguredDirectory("inputDirectory");
-  const entries = await readdir(inputDirectory, { withFileTypes: true });
+  const entries = await inputStorage.listFiles(".");
   const matches = [];
   for (const entry of entries) {
-    if (entry.isFile()) {
-      const filename = entry.name;
-      const ext = filename.split(".").pop()?.toLowerCase();
-      if (ext && DEFAULT_AUDIO_EXTENSIONS.includes(ext)) {
-        if (filename === filenameOrPath || filename.includes(filenameOrPath) || basename(filename, `.${ext}`) === filenameOrPath) {
-          matches.push(join(inputDirectory, filename));
-        }
+    const filename = basename(entry);
+    const ext = filename.split(".").pop()?.toLowerCase();
+    if (ext && DEFAULT_AUDIO_EXTENSIONS.includes(ext)) {
+      if (filename === filenameOrPath || filename.includes(filenameOrPath) || basename(filename, `.${ext}`) === filenameOrPath) {
+        matches.push(entry);
       }
     }
   }
@@ -2354,7 +3301,19 @@ async function findAudioFile(filenameOrPath) {
     );
   }
   if (matches.length === 1) {
-    return matches[0];
+    const matchedPath = matches[0];
+    if (inputStorage.name === "filesystem") {
+      return join(inputDirectory, matchedPath);
+    }
+    const contents = await inputStorage.readFile(matchedPath);
+    const tempRoot = join(tmpdir(), "protokoll-gcs-input");
+    await mkdir(tempRoot, { recursive: true });
+    const tempPath = join(
+      tempRoot,
+      `${Date.now()}-${Math.random().toString(36).slice(2)}-${basename(matchedPath)}`
+    );
+    await writeFile(tempPath, contents);
+    return tempPath;
   }
   const matchNames = matches.map((m) => basename(m)).join(", ");
   throw new Error(
@@ -2510,7 +3469,7 @@ async function getContextInstance(contextDirectory) {
     );
   }
   const serverContext = ServerConfig.getContext();
-  if (serverContext) {
+  if (serverContext?.hasContext()) {
     return serverContext;
   }
   return createToolContext(contextDirectory);
@@ -7472,5 +8431,5 @@ async function initializeWorkingDirectoryFromArgsAndConfig() {
   }
 }
 
-export { DEFAULT_CONFIG_FILE as D, handleListResources as a, handleReadResource as b, getPrompt as c, initializeServerConfig as d, getCachedRoots as e, getOutputDirectory as f, getPrompts as g, handleToolCall as h, initializeWorkingDirectoryFromArgsAndConfig as i, getServerConfig as j, getContext as k, createQuietLogger as l, setWorkerInstance as m, setRoots as s, tools as t };
+export { DEFAULT_CONFIG_FILE as D, handleListResources as a, handleReadResource as b, getPrompt as c, initializeServerConfig as d, getCachedRoots as e, getOutputDirectory as f, getPrompts as g, handleToolCall as h, initializeWorkingDirectoryFromArgsAndConfig as i, getOutputStorage as j, getServerConfig as k, getStorageConfig as l, getContext as m, createQuietLogger as n, setWorkerInstance as o, setRoots as s, tools as t };
 //# sourceMappingURL=configDiscovery.js.map