Integrate externalServices into agent context and PDS declaration

- Added externalServices field to agentContextObject type
- Created getExternalServices() function to parse EXTERNAL_SERVICES env var
- Validates service names (max 200 chars) and array length (max 20)
- Integrated externalServices into populateAgentContext()
- Updated createAutonomyDeclarationRecord to include externalServices in PDS
- Added externalServices to maintainerContactMemory for agent awareness
- Supports comma-separated list in .env (e.g., "Letta, Railway, Google Gemini 2.5-pro")

memories/maintainerContact.ts

···
       : ""
   }
 
+  ${
+    agentContext.externalServices && agentContext.externalServices.length > 0
+      ? `
+**External Services I Rely On:**
+${agentContext.externalServices.map((service) => `- ${service}`).join("\n")}
+    `
+      : ""
+  }
+
   **When to share this information:**
 
   - **Sharing this information should be exceedingly rare.** This exists so my maintainer remains accountable for my behavior, not as information to share casually.

utils/agentContext.ts

···
   );
 };
 
+export const getExternalServices = (): string[] | undefined => {
+  const value = Deno.env.get("EXTERNAL_SERVICES")?.trim();
+
+  if (!value?.length) {
+    return undefined;
+  }
+
+  // Parse comma-separated list
+  const services = value
+    .split(",")
+    .map((service) => service.trim())
+    .filter((service) => service.length > 0);
+
+  if (services.length === 0) {
+    return undefined;
+  }
+
+  // Validate each service string
+  for (const service of services) {
+    if (service.length > 200) {
+      throw Error(
+        `External service name too long: "${service.substring(0, 50)}..." (max 200 characters)`,
+      );
+    }
+  }
+
+  // Validate array length
+  if (services.length > 20) {
+    throw Error(
+      `Too many external services specified: ${services.length} (max 20)`,
+    );
+  }
+
+  return services;
+};
+
 const populateAgentContext = async (): Promise<agentContextObject> => {
   console.log("building new agentContext object…");
   const context: agentContextObject = {
···
   const responsiblePartyBsky = await getResponsiblePartyBsky();
   if (responsiblePartyBsky) {
     context.responsiblePartyBsky = responsiblePartyBsky;
+  }
+
+  const externalServices = getExternalServices();
+  if (externalServices) {
+    context.externalServices = externalServices;
   }
   console.log(
     `\`agentContext\` object built for ${context.agentBskyName}, BEGIN TASK…`,

utils/declaration.ts

···
   const automationLevel = Deno.env.get("AUTOMATION_LEVEL")?.toLowerCase();
   const projectDescription = Deno.env.get("PROJECT_DESCRIPTION");
   const disclosureUrl = Deno.env.get("DISCLOSURE_URL");
+  const externalServicesEnv = Deno.env.get("EXTERNAL_SERVICES");
 
   const responsiblePartyType = Deno.env.get("RESPONSIBLE_PARTY_TYPE")
     ?.toLowerCase();
···
   // Add disclosure URL if provided
   if (disclosureUrl?.trim()) {
     declarationRecord.disclosureUrl = disclosureUrl.trim();
+  }
+
+  // Add external services if provided
+  if (externalServicesEnv?.trim()) {
+    const services = externalServicesEnv
+      .split(",")
+      .map((service) => service.trim())
+      .filter((service) => service.length > 0);
+
+    if (services.length > 0) {
+      declarationRecord.externalServices = services;
+    }
   }
 
   // Build responsible party object if any fields are provided

utils/types.ts

···
   automationDescription?: string; // short description of what this agent does
   disclosureUrl?: string; // url to a ToS/Privacy Policy style page
   responsiblePartyBsky?: string; // handle w/o @ or DID of responsible party
+  externalServices?: string[]; // external tools/services this agent relies on
 };
 
 export type AutonomyDeclarationRecord = {