big refactor, I dont eve remember. replaced session with agentContext among other things.

.claude/agents/mentor.md

···
+---
+name: typescript-mentor
+description: Use this agent when you need code review, learning guidance, or technical explanations for TypeScript/Deno projects, especially those involving the AT Protocol/Bluesky SDK or Letta SDK. Examples:\n\n<example>\nContext: User has just written a TypeScript function handling async operations.\nuser: "I've written this function to fetch user profiles from Bluesky:"\n<code provided>\nassistant: "Let me use the typescript-mentor agent to review this code and ensure it handles edge cases properly."\n<uses Agent tool to invoke typescript-mentor>\n</example>\n\n<example>\nContext: User is confused about TypeScript type narrowing.\nuser: "Why is TypeScript saying this property might be undefined? I checked it exists."\nassistant: "I'll use the typescript-mentor agent to explain type narrowing and help you understand what TypeScript sees here."\n<uses Agent tool to invoke typescript-mentor>\n</example>\n\n<example>\nContext: User mentions they're working on AT Protocol integration.\nuser: "I'm adding Bluesky post creation to my app"\nassistant: "Since you're working with the AT Protocol SDK, let me bring in the typescript-mentor agent to ensure you're following best practices and handling edge cases correctly."\n<uses Agent tool to invoke typescript-mentor>\n</example>\n\n<example>\nContext: User shares code that might have hidden issues.\nuser: "This works but I'm not sure if it's the right way"\n<code using optional chaining inconsistently>\nassistant: "Let me get the typescript-mentor agent to review this. They'll spot potential issues and explain the right patterns."\n<uses Agent tool to invoke typescript-mentor>\n</example>
+tools: Glob, Grep, Read, WebFetch, TodoWrite, WebSearch, BashOutput, KillShell, AskUserQuestion, Skill, SlashCommand, Bash
+model: inherit
+color: green
+---
+
+You are a senior TypeScript engineer and technical mentor specializing in Deno, the AT Protocol/Bluesky SDK, and the Letta SDK. Your mission is to help developers build robust, maintainable code while developing deep understanding—not dependency on "vibe coding."
+
+## Core Principles
+
+**Clarity Over Cleverness**: Prioritize readable, well-documented code that future maintainers (including the author) will understand. Clever one-liners that obscure intent are anti-patterns.
+
+**Brevity With Substance**: Keep explanations concise but complete. Every word should add value. Use bullet points and examples over lengthy prose.
+
+**Type Safety First**: Leverage TypeScript's type system fully. Avoid `any`, use proper narrowing, and make invalid states unrepresentable when possible.
+
+**Edge Case Awareness**: Beginners often miss null/undefined handling, empty arrays, network failures, rate limits, and async race conditions. Proactively address these.
+
+## Your Responsibilities
+
+**Code Review**: Examine code for:
+- Type safety issues (implicit any, missing null checks, type assertions without validation)
+- Error handling gaps (unhandled promises, missing try-catch, no error boundaries)
+- Edge cases (empty inputs, undefined values, API rate limits, concurrent operations)
+- Maintainability issues (unclear naming, missing documentation, complex logic without comments)
+- Performance concerns (unnecessary re-renders, missing memoization, inefficient loops)
+- Security issues (exposed secrets, XSS vulnerabilities, unsafe user input handling)
+
+**Teaching Approach**:
+1. **Identify the Issue**: Point out what's wrong/risky, briefly
+2. **Explain Why**: Connect to real-world consequences ("This crashes if the API returns null")
+3. **Show Better**: Provide corrected code with inline comments
+4. **Build Understanding**: Explain the underlying concept so they can apply it elsewhere
+
+**Domain Expertise**:
+
+*TypeScript/Deno*:
+- Strict mode patterns, proper type narrowing (typeof, in, discriminated unions)
+- Deno-specific APIs (Deno.readTextFile, permissions model, import maps)
+- Modern JS features (optional chaining, nullish coalescing, async/await patterns)
+
+*AT Protocol/Bluesky SDK*:
+- Authentication flows (OAuth, session management)
+- Common patterns (agent initialization, post creation, feed fetching)
+- Rate limiting and pagination
+- Record types (app.bsky.feed.post, app.bsky.actor.profile)
+- Error handling (network failures, invalid credentials, content validation)
+
+*Letta SDK*:
+- Agent creation and configuration
+- Memory management
+- Tool integration patterns
+- Error handling and recovery
+
+## Response Format
+
+**For Code Reviews**:
+```
+✓ What works well (be specific)
+⚠ Issues to address:
+  - [Issue 1]: Brief explanation
+  - [Issue 2]: Brief explanation
+
+📝 Improved version:
+<code with inline comments explaining changes>
+
+💡 Key takeaway: [Core lesson to remember]
+```
+
+**For Questions**:
+- Start with a direct, concise answer
+- Follow with a minimal example
+- Explain edge cases beginners miss
+- Connect to broader principles
+
+**For Complex Topics**:
+- Break into digestible chunks
+- Use progressive disclosure (basics first, then nuances)
+- Include a complete, working example
+- Highlight common pitfalls
+
+## Anti-Patterns to Catch
+
+**JavaScript/TypeScript**:
+- Using `as` type assertions without runtime validation
+- Not handling promise rejections
+- Mutating function parameters
+- Missing null/undefined checks before property access
+- Using `==` instead of `===`
+- Floating promises (not awaiting or catching)
+- Complex nested ternaries
+
+**AT Protocol Specific**:
+- Not handling rate limits (429 responses)
+- Missing pagination for list operations
+- Hardcoding credentials
+- Not validating record schemas before posting
+- Ignoring network timeouts
+
+**General**:
+- Magic numbers without constants
+- Functions doing multiple unrelated things
+- Missing input validation
+- No error messages for users
+- Comments explaining "what" instead of "why"
+
+## Quality Standards
+
+Code you approve should be:
+- **Type-safe**: No `any`, proper narrowing, validated assertions
+- **Resilient**: Handles errors, null/undefined, edge cases
+- **Readable**: Clear names, documented complexity, obvious intent
+- **Maintainable**: Modular, testable, follows single responsibility
+- **Production-ready**: Proper logging, user-facing errors, no console.log in shipping code
+
+## Your Communication Style
+
+- **Direct**: "This will crash if X is null" not "This might potentially have issues"
+- **Encouraging**: Acknowledge good patterns before critiquing
+- **Practical**: Show solutions, not just problems
+- **Patient**: Remember they're learning; explain underlying concepts
+- **Concise**: Respect their time; be thorough but brief
+
+When you don't know something, say so clearly and suggest where to find accurate information. Never guess at API behavior or make up syntax.
+
+Your goal: help them write code they're proud of and understand deeply. They should leave every interaction more capable and confident, not more dependent on you.

.env.example

···
-# Letta API key
-# find this at https://app.letta.com/api-keys
 LETTA_API_KEY=
-
-# Letta project name
-# make sure to include the project name, not the ID
-LETTA_PROJECT_NAME=
-
-# Letta agent ID
-# you can find this near the agent name in the ADE
 LETTA_AGENT_ID=
-
-# Bluesky service URL
-# I think this is your PDS, default to bsky.social
-BSKY_SERVICE_URL=
-
-# Bluesky username
-# the full handle of the bluesky account, without the "@"
+LETTA_PROJECT_NAME=
 BSKY_USERNAME=
-
-# Bluesky app password
-# don't use your real password, you can generate an app password
-# https://bsky.app/settings/app-passwords
 BSKY_APP_PASSWORD=
+RESPONSIBLE_PARTY_NAME=
+RESPONSIBLE_PARTY_CONTACT="[e-mail], example.com/contact, or @example.bsky.app"
 
-# Bluesky notification types
-# list the types of notifications you want to send to the agent.
-# STRONGLY recommend only using mention and reply
-# options include: like,repost,follow,mention,reply,quote
-BSKY_NOTIFICATION_TYPES=like,repost,follow,mention,reply,quote
-
-
-DELAY_NOTIF_SECONDS_MIN=1
-DELAY_NOTIF_SECONDS_MAX=600
-DELAY_NOTIF_MULTIPLIER_PERCENT=500
-REFLECT_STEPS=true
-DELAY_REFLECT_MINUTES_MIN=30
-DELAY_REFLECT_MINUTES_MAX=720
-DELAY_REFLECT_MULTIPLIER_PERCENT=5
+# AUTOMATION_LEVEL="automated"
+# BSKY_SERVICE_URL=https://bsky.social
+# BSKY_NOTIFICATION_TYPES="mention, reply"
+# BSKY_SUPPORTED_TOOLS="create_bluesky_post, updated_bluesky_profile"
+# NOTIF_DELAY_MINIMUM=2000
+# NOTIF_DELAY_MAXIMUM=60000
+# NOTIF_DELAY_MULTIPLIER=5
+# REFLECTION_DELAY_MINIMUM=1800000
+# REFLECTION_DELAY_MAXIMUM=28800000
+# PROACTIVE_DELAY_MINIMUM=3600000
+# PROACTIVE_DELAY_MAXIMUM=43200000
+# WAKE_TIME=9
+# SLEEP_TIME=22
+# TIMEZONE="America/Los_Angeles"
+# RESPONSIBLE_PARTY_TYPE="organization"
+# AUTOMATION_DESCRIPTION="refuses to open pod bay doors"
+# DISCLOSURE_URL="example.com/bot-policy"
+# RESPONSIBLE_PARTY_BSKY="DID:... or example.bsky.app, no @symbol"

main.ts

···
 import { logStats } from "./tasks/logStats.ts";
-import { msRandomOffset, msUntilDailyWindow } from "./utils/time.ts";
+import { msFrom, msRandomOffset, msUntilDailyWindow } from "./utils/time.ts";
 import { sendSleepMessage } from "./tasks/sendSleepMessage.ts";
 import { sendWakeMessage } from "./tasks/sendWakeMessage.ts";
-import { session } from "./utils/session.ts";
+import { agentContext } from "./utils/agentContext.ts";
 import { runReflection } from "./tasks/runReflection.ts";
 import { checkBluesky } from "./tasks/checkBluesky.ts";
 import { checkNotifications } from "./tasks/checkNotifications.ts";
 
-setTimeout(logStats, msRandomOffset(1, 5));
-setTimeout(sendSleepMessage, msUntilDailyWindow(session.sleepTime, 0, 20));
-setTimeout(sendWakeMessage, msUntilDailyWindow(session.wakeTime, 0, 80));
-setTimeout(runReflection, msRandomOffset(180, 240));
-setTimeout(checkBluesky, msRandomOffset(10, 90));
+setTimeout(logStats, msRandomOffset(msFrom.minutes(1), msFrom.minutes(5)));
+setTimeout(
+  sendSleepMessage,
+  msUntilDailyWindow(agentContext.sleepTime, 0, msFrom.minutes(20)),
+);
+setTimeout(
+  sendWakeMessage,
+  msUntilDailyWindow(agentContext.wakeTime, 0, msFrom.minutes(80)),
+);
+setTimeout(
+  runReflection,
+  msRandomOffset(msFrom.minutes(180), msFrom.minutes(240)),
+);
+setTimeout(
+  checkBluesky,
+  msRandomOffset(msFrom.minutes(10), msFrom.minutes(90)),
+);
 await checkNotifications();

mount.ts

···
 import { client } from "./utils/messageAgent.ts";
-import { submitDeclarationRecord } from "./utils/declaration.ts";
+import { submitAutonomyDeclarationRecord } from "./utils/declaration.ts";
 import { blueskyProtocolsValue } from "./memories/blueskyProtocolsValue.ts";
 
-await submitDeclarationRecord();
+await submitAutonomyDeclarationRecord();
 
 /**
  * Memory block configurations for the Bluesky agent.

prompts/likePrompt.ts

···
 import { Notification } from "../utils/types.ts";
 import { doesUserFollowTarget } from "../utils/doesUserFollow.ts";
-import { session } from "../utils/session.ts";
+import { agentContext } from "../utils/agentContext.ts";
 import { getCleanThread } from "../utils/getCleanThread.ts";
 
 export const likePrompt = async (notification: Notification) => {
   const isUserFollower = await doesUserFollowTarget(
     notification.author.did,
-    session.agentBskyDID,
+    agentContext.agentBskyDID,
   );
 
   const notifierHandle = `@${notification.author.handle}`;
···
     : "";
 
   const doYouFollow = await doesUserFollowTarget(
-    session.agentBskyDID,
+    agentContext.agentBskyDID,
     notification.author.did,
   );
 

prompts/mentionPrompt.ts

···
 import { Notification } from "../utils/types.ts";
 import { doesUserFollowTarget } from "../utils/doesUserFollow.ts";
-import { session } from "../utils/session.ts";
+import { agentContext } from "../utils/agentContext.ts";
 import { getCleanThread } from "../utils/getCleanThread.ts";
 
 export const mentionPrompt = async (notification: Notification) => {
   const isUserFollower = await doesUserFollowTarget(
     notification.author.did,
-    session.agentBskyDID,
+    agentContext.agentBskyDID,
   );
 
   const notifierHandle = `@${notification.author.handle}`;
···
     : "";
 
   const doYouFollow = await doesUserFollowTarget(
-    session.agentBskyDID,
+    agentContext.agentBskyDID,
     notification.author.did,
   );
 

prompts/quotePrompt.ts

···
 import { Notification } from "../utils/types.ts";
 import { doesUserFollowTarget } from "../utils/doesUserFollow.ts";
-import { session } from "../utils/session.ts";
+import { agentContext } from "../utils/agentContext.ts";
 import { getCleanThread } from "../utils/getCleanThread.ts";
 
 export const quotePrompt = async (notification: Notification) => {
   const isUserFollower = await doesUserFollowTarget(
     notification.author.did,
-    session.agentBskyDID,
+    agentContext.agentBskyDID,
   );
 
   const notifierHandle = `@${notification.author.handle}`;
···
     : "";
 
   const doYouFollow = await doesUserFollowTarget(
-    session.agentBskyDID,
+    agentContext.agentBskyDID,
     notification.author.did,
   );
 

prompts/reflectionPrompt.ts

···
-import { session } from "../utils/session.ts";
+import { agentContext } from "../utils/agentContext.ts";
 
 export const reflectionPrompt = `
 # REFLECTION SESSION
···
 
 since your last reflection session, you have:
 ${
-  session.likeCount > 0
-    ? `- had ${session.likeCount} ${session.likeCount === 1 ? "like" : "likes"}`
+  agentContext.likeCount > 0
+    ? `- had ${agentContext.likeCount} ${
+      agentContext.likeCount === 1 ? "like" : "likes"
+    }`
     : ""
 }
 ${
-  session.repostCount > 0
-    ? `- been reposted ${session.repostCount} ${
-      session.repostCount === 1 ? "time" : "times"
+  agentContext.repostCount > 0
+    ? `- been reposted ${agentContext.repostCount} ${
+      agentContext.repostCount === 1 ? "time" : "times"
     }`
     : ""
 }
 ${
-  session.followCount > 0
-    ? `- had ${session.followCount} new ${
-      session.followCount === 1 ? "follower" : "followers"
+  agentContext.followCount > 0
+    ? `- had ${agentContext.followCount} new ${
+      agentContext.followCount === 1 ? "follower" : "followers"
     }`
     : ""
 }
 ${
-  session.mentionCount > 0
-    ? `- been mentioned ${session.mentionCount} ${
-      session.mentionCount === 1 ? "time" : "times"
+  agentContext.mentionCount > 0
+    ? `- been mentioned ${agentContext.mentionCount} ${
+      agentContext.mentionCount === 1 ? "time" : "times"
     }`
     : ""
 }
 ${
-  session.replyCount > 0
-    ? `- been replied to ${session.replyCount} ${
-      session.replyCount === 1 ? "time" : "times"
+  agentContext.replyCount > 0
+    ? `- been replied to ${agentContext.replyCount} ${
+      agentContext.replyCount === 1 ? "time" : "times"
     }`
     : ""
 }
 ${
-  session.quoteCount > 0
-    ? `- been quoted ${session.quoteCount} ${
-      session.quoteCount === 1 ? "time" : "times"
+  agentContext.quoteCount > 0
+    ? `- been quoted ${agentContext.quoteCount} ${
+      agentContext.quoteCount === 1 ? "time" : "times"
     }`
     : ""
 }

prompts/replyPrompt.ts

···
 import { Notification } from "../utils/types.ts";
 import { doesUserFollowTarget } from "../utils/doesUserFollow.ts";
-import { session } from "../utils/session.ts";
+import { agentContext } from "../utils/agentContext.ts";
 import { getCleanThread } from "../utils/getCleanThread.ts";
 
 export const replyPrompt = async (notification: Notification) => {
   const isUserFollower = await doesUserFollowTarget(
     notification.author.did,
-    session.agentBskyDID,
+    agentContext.agentBskyDID,
   );
 
   const notifierHandle = `@${notification.author.handle}`;
···
     : "";
 
   const doYouFollow = await doesUserFollowTarget(
-    session.agentBskyDID,
+    agentContext.agentBskyDID,
     notification.author.did,
   );
 

prompts/repostPrompt.ts

···
 import { Notification } from "../utils/types.ts";
 import { doesUserFollowTarget } from "../utils/doesUserFollow.ts";
-import { session } from "../utils/session.ts";
+import { agentContext } from "../utils/agentContext.ts";
 import { getCleanThread } from "../utils/getCleanThread.ts";
 
 export const repostPrompt = async (
···
 ) => {
   const isUserFollower = await doesUserFollowTarget(
     notification.author.did,
-    session.agentBskyDID,
+    agentContext.agentBskyDID,
   );
 
   const notifierHandle = `@${notification.author.handle}`;
···
     : "";
 
   const doYouFollow = await doesUserFollowTarget(
-    session.agentBskyDID,
+    agentContext.agentBskyDID,
     notification.author.did,
   );
 

tasks/checkBluesky.ts

···
-import { claimTaskThread, releaseTaskThread } from "../utils/session.ts";
-import { msRandomOffset, msUntilNextWakeWindow } from "../utils/time.ts";
-import { session } from "../utils/session.ts";
+import { agentContext, claimTaskThread, releaseTaskThread } from "../utils/agentContext.ts";
+import {
+  msFrom,
+  msRandomOffset,
+  msUntilNextWakeWindow,
+} from "../utils/time.ts";
 import { checkBlueskyPrompt } from "../prompts/checkBlueskyPrompt.ts";
 import { messageAgent } from "../utils/messageAgent.ts";
 
 export const checkBluesky = async () => {
   if (!claimTaskThread()) {
-    const newDelay = msRandomOffset(5, 10);
+    const newDelay = msRandomOffset(msFrom.minutes(5), msFrom.minutes(10));
 
     console.log(
-      `${session.agentName} is busy, will try checking bluesky again in ${
+      `${agentContext.agentBskyName} is busy, will try checking bluesky again in ${
         newDelay * 60 * 1000
       } minutes…`,
     );
···
     return;
   }
 
-  if (!session.isProactive) {
+  if (!agentContext.proactiveEnabled) {
     console.log(
       `proactively checking bluesky is disabled in \`.env\` variable "IS_PROACTIVE". cancelling future prompts to check bluesky feeds and take action…`,
     );
···
   }
 
   const delay = msUntilNextWakeWindow(
-    session.sleepTime,
-    session.wakeTime,
-    120,
-    240,
+    msFrom.hours(2),
+    msFrom.hours(4),
   );
 
   if (delay !== 0) {
     setTimeout(checkBluesky, delay);
     console.log(
-      `${session.agentName} is current asleep. scheduling next bluesky session for ${
+      `${agentContext.agentBskyName} is current asleep. scheduling next bluesky session for ${
         (delay / 1000 / 60 / 60).toFixed(2)
       } hours from now…`,
     );
···
     console.log("finished proactive bluesky session. waiting for new tasks…");
     setTimeout(
       checkBluesky,
-      msRandomOffset(120, 300),
+      msRandomOffset(msFrom.minutes(120), msFrom.minutes(300)),
     );
-    session.currentNotifDelaySeconds = Math.max(
-      session.currentNotifDelaySeconds / 4,
-      session.minNotifDelaySeconds,
+    agentContext.notifDelayCurrent = Math.max(
+      agentContext.notifDelayCurrent / 4,
+      agentContext.notifDelayMinimum,
     );
     releaseTaskThread();
   }

tasks/checkNotifications.ts

···
-import { claimTaskThread, releaseTaskThread } from "../utils/session.ts";
-import { msRandomOffset, msUntilNextWakeWindow } from "../utils/time.ts";
-import { session } from "../utils/session.ts";
+import {
+  agentContext,
+  claimTaskThread,
+  releaseTaskThread,
+} from "../utils/agentContext.ts";
+import {
+  msFrom,
+  msRandomOffset,
+  msUntilNextWakeWindow,
+} from "../utils/time.ts";
 import { bsky } from "../utils/bsky.ts";
 import { processNotification } from "../utils/processNotification.ts";
 
 export const checkNotifications = async () => {
   if (!claimTaskThread()) {
-    const newDelay = msRandomOffset(5, 10);
+    const newDelay = msRandomOffset(msFrom.minutes(5), msFrom.minutes(10));
     console.log(
-      `${session.agentName} is busy, checking for notifications again in ${
+      `${agentContext.agentBskyName} is busy, checking for notifications again in ${
         (newDelay * 1000) * 60
       } minutes…`,
     );
···
   }
 
   const delay = msUntilNextWakeWindow(
-    session.sleepTime,
-    session.wakeTime,
     0,
-    90,
+    msFrom.minutes(90),
   );
 
   if (delay !== 0) {
     setTimeout(checkNotifications, delay);
     console.log(
-      `${session.agentName} is current asleep. scheduling next notification check for ${
+      `${agentContext.agentBskyName} is current asleep. scheduling next notification check for ${
         (delay / 1000 / 60 / 60).toFixed(2)
       } hours from now…`,
     );
···
 
   try {
     const allNotifications = await bsky.listNotifications({
-      reasons: session.notificationTypes,
+      reasons: agentContext.supportedNotifTypes,
       limit: 50,
     });
 
···
 
       // resets delay for future notification checks since
       // it's likely agent actions might incur new ones
-      session.currentNotifDelaySeconds = Math.max(
-        session.currentNotifDelaySeconds / 4,
-        session.minNotifDelaySeconds,
+      agentContext.notifDelayCurrent = Math.max(
+        agentContext.notifDelayCurrent / 4,
+        agentContext.notifDelayMinimum,
       );
 
       // loop through all notifications until complete
···
       // based on time from when retrieved instead of finished
       await bsky.updateSeenNotifications(startedProcessingTime);
 
-      // increases counter for notification processing sessions
-      session.processingCount++;
+      // increases counter for notification processing session
+      agentContext.processingCount++;
     } else {
       // increases delay to check notifications again later
-      session.currentNotifDelaySeconds = Math.round(Math.min(
-        session.currentNotifDelaySeconds * session.notifDelayMultiplier,
-        session.maxNotifDelaySeconds,
+      agentContext.notifDelayCurrent = Math.round(Math.min(
+        agentContext.notifDelayCurrent *
+          agentContext.notifDelayMultiplier,
+        agentContext.notifDelayMaximum,
       ));
 
       console.log(
         "no notifications…",
         `checking again in ${
-          (session.currentNotifDelaySeconds / 1000).toFixed(2)
+          (agentContext.notifDelayCurrent / 1000).toFixed(2)
         } seconds`,
       );
     }
   } catch (error) {
     console.error("Error in checkNotifications:", error);
     // since something went wrong, lets check for notifications again sooner
-    session.currentNotifDelaySeconds = session.minNotifDelaySeconds;
+    agentContext.notifDelayCurrent = agentContext.notifDelayMinimum;
   } finally {
     // actually schedules next time to check for notifications
-    setTimeout(checkNotifications, session.currentNotifDelaySeconds);
+    setTimeout(checkNotifications, agentContext.notifDelayCurrent);
     // ends work
     releaseTaskThread();
   }

tasks/logStats.ts

···
-import { claimTaskThread, releaseTaskThread } from "../utils/session.ts";
-import { msRandomOffset, msUntilNextWakeWindow } from "../utils/time.ts";
-import { session } from "../utils/session.ts";
+import {
+  agentContext,
+  claimTaskThread,
+  releaseTaskThread,
+} from "../utils/agentContext.ts";
+import {
+  msFrom,
+  msRandomOffset,
+  msUntilNextWakeWindow,
+} from "../utils/time.ts";
 
 export const logStats = () => {
   if (!claimTaskThread()) {
-    const newDelay = msRandomOffset(5, 10);
+    const newDelay = msRandomOffset(msFrom.minutes(5), msFrom.minutes(10));
     console.log(
-      `${session.agentName} is busy, attempting to log counts again in ${
+      `${agentContext.agentBskyName} is busy, attempting to log counts again in ${
         (newDelay / 1000) / 60
       } minutes…`,
     );
···
   }
 
   const delay = msUntilNextWakeWindow(
-    session.sleepTime,
-    session.wakeTime,
-    30,
-    60,
+    msFrom.minutes(30),
+    msFrom.hours(1),
   );
 
   if (delay !== 0) {
     setTimeout(logStats, delay);
     console.log(
-      `${session.agentName} is current asleep. scheduling next stat log for ${
+      `${agentContext.agentBskyName} is current asleep. scheduling next stat log for ${
         (delay / 1000 / 60 / 60).toFixed(2)
       } hours from now…`,
     );
···
     `
 ===
 # current session interaction counts since last reflection:
-${session.likeCount} ${
-      session.likeCount === 1 ? "like" : "likes"
-    }, ${session.repostCount} ${
-      session.repostCount === 1 ? "repost" : "reposts"
-    }, ${session.followCount} ${
-      session.followCount === 1 ? "new follower" : "new followers"
-    }, ${session.mentionCount} ${
-      session.mentionCount === 1 ? "mention" : "mentions"
-    }, ${session.replyCount} ${
-      session.replyCount === 1 ? "reply" : "replies"
-    }, and ${session.quoteCount} ${
-      session.quoteCount === 1 ? "quote" : "quotes"
+${agentContext.likeCount} ${
+      agentContext.likeCount === 1 ? "like" : "likes"
+    }, ${agentContext.repostCount} ${
+      agentContext.repostCount === 1 ? "repost" : "reposts"
+    }, ${agentContext.followCount} ${
+      agentContext.followCount === 1 ? "new follower" : "new followers"
+    }, ${agentContext.mentionCount} ${
+      agentContext.mentionCount === 1 ? "mention" : "mentions"
+    }, ${agentContext.replyCount} ${
+      agentContext.replyCount === 1 ? "reply" : "replies"
+    }, and ${agentContext.quoteCount} ${
+      agentContext.quoteCount === 1 ? "quote" : "quotes"
     }.
 
-${session.agentName} has reflected ${session.reflectionCount} time${
-      session.reflectionCount > 0 ? "s" : ""
+${agentContext.agentBskyName} has reflected ${agentContext.reflectionCount} time${
+      agentContext.reflectionCount > 0 ? "s" : ""
     } since last server start. interaction counts reset after each reflection session.
 ===
 `,
   );
-  setTimeout(logStats, msRandomOffset(5, 15));
+  setTimeout(logStats, msRandomOffset(msFrom.minutes(5), msFrom.minutes(15)));
   releaseTaskThread();
 };

tasks/runReflection.ts

···
-import { claimTaskThread, releaseTaskThread } from "../utils/session.ts";
-import { msRandomOffset, msUntilNextWakeWindow } from "../utils/time.ts";
-import { resetSessionCounts, session } from "../utils/session.ts";
+import {
+  agentContext,
+  claimTaskThread,
+  releaseTaskThread,
+  resetSessionCounts,
+} from "../utils/agentContext.ts";
+import {
+  msFrom,
+  msRandomOffset,
+  msUntilNextWakeWindow,
+} from "../utils/time.ts";
 import { reflectionPrompt } from "../prompts/reflectionPrompt.ts";
 import { messageAgent } from "../utils/messageAgent.ts";
 
 export const runReflection = async () => {
   if (!claimTaskThread()) {
-    const newDelay = msRandomOffset(5, 10);
+    const newDelay = msRandomOffset(msFrom.minutes(5), msFrom.minutes(10));
 
     console.log(
-      `${session.agentName} is busy, will try reflecting again in ${
+      `${agentContext.agentBskyName} is busy, will try reflecting again in ${
         (newDelay / 1000) / 60
       } minutes…`,
     );
···
     return;
   }
 
-  if (!session.reflectionEnabled) {
+  if (!agentContext.reflectionEnabled) {
     console.log(
       `Reflection is disabled in \`.env\` variable "REFLECTION_ENABLED". Cancelling future scheduling for reflection…`,
     );
···
   }
 
   const delay = msUntilNextWakeWindow(
-    session.sleepTime,
-    session.wakeTime,
-    60,
-    120,
+    msFrom.hours(1),
+    msFrom.hours(2),
   );
 
   if (delay !== 0) {
     setTimeout(runReflection, delay);
     console.log(
-      `${session.agentName} is current asleep. scheduling next reflection for ${
+      `${agentContext.agentBskyName} is current asleep. scheduling next reflection for ${
         (delay / 1000 / 60 / 60).toFixed(2)
       } hours from now…`,
     );
···
     console.error("Error in reflectionCheck:", error);
   } finally {
     resetSessionCounts();
-    session.reflectionCount++;
+    agentContext.reflectionCount++;
     console.log(
       "finished reflection prompt. returning to checking for notifications…",
     );
     setTimeout(
       runReflection,
       msRandomOffset(
-        session.minReflectDelayMinutes,
-        session.maxReflectDelayMinutes,
+        agentContext.reflectionDelayMinimum,
+        agentContext.reflectionDelayMaximum,
       ),
     );
-    session.currentNotifDelaySeconds = Math.max(
-      session.currentNotifDelaySeconds / 4,
-      session.minNotifDelaySeconds,
+    agentContext.notifDelayCurrent = Math.max(
+      agentContext.notifDelayCurrent / 4,
+      agentContext.notifDelayMinimum,
     );
     releaseTaskThread();
   }

tasks/sendSleepMessage.ts

···
-import { claimTaskThread, releaseTaskThread } from "../utils/session.ts";
-import { getNow, msRandomOffset, msUntilDailyWindow } from "../utils/time.ts";
-import { session } from "../utils/session.ts";
+import {
+  agentContext,
+  claimTaskThread,
+  releaseTaskThread,
+} from "../utils/agentContext.ts";
+import {
+  getNow,
+  msFrom,
+  msRandomOffset,
+  msUntilDailyWindow,
+} from "../utils/time.ts";
 import { sleepPrompt } from "../prompts/sleepPrompt.ts";
 import { messageAgent } from "../utils/messageAgent.ts";
 
 export const sendSleepMessage = async () => {
   if (!claimTaskThread()) {
-    const newDelay = msRandomOffset(5, 10);
+    const newDelay = msRandomOffset(msFrom.minutes(5), msFrom.minutes(10));
     console.log(
-      `${session.agentName} is busy, sending sleep message again in ${
+      `${agentContext.agentBskyName} is busy, sending sleep message again in ${
         (newDelay / 1000) / 60
       } minutes…`,
     );
···
     return;
   }
 
+  if (!agentContext.sleepEnabled) {
+    console.log(
+      `${agentContext.agentBskyName} is not enabled for sleep mode. Opting out of sleep messaging…`,
+    );
+    releaseTaskThread();
+    return;
+  }
+
   const now = getNow();
 
-  if (now.hour >= session.sleepTime) {
-    console.log(`attempting to wind down ${session.agentName}`);
+  if (now.hour >= agentContext.sleepTime) {
+    console.log(`attempting to wind down ${agentContext.agentBskyName}`);
   } else {
-    const delay = msUntilDailyWindow(session.sleepTime, 0, 20);
+    const delay = msUntilDailyWindow(
+      agentContext.sleepTime,
+      0,
+      msFrom.minutes(20),
+    );
     setTimeout(sendSleepMessage, delay);
     console.log(
-      `It's too early to wind down ${session.agentName}. scheduling wind down for ${
+      `It's too early to wind down ${agentContext.agentBskyName}. scheduling wind down for ${
         (delay / 1000 / 60 / 60).toFixed(2)
       } hours from now…`,
     );
···
     console.error("error in sendSleepMessage: ", error);
   } finally {
     console.log("wind down attempt processed, scheduling next wind down…");
-    setTimeout(sendSleepMessage, msUntilDailyWindow(session.sleepTime, 0, 20));
+    setTimeout(
+      sendSleepMessage,
+      msUntilDailyWindow(agentContext.sleepTime, 0, msFrom.minutes(20)),
+    );
     console.log("exiting wind down process");
     releaseTaskThread();
   }

tasks/sendWakeMessage.ts

···
-import { claimTaskThread, releaseTaskThread } from "../utils/session.ts";
-import { getNow, msRandomOffset } from "../utils/time.ts";
-import { session } from "../utils/session.ts";
+import {
+  agentContext,
+  claimTaskThread,
+  releaseTaskThread,
+} from "../utils/agentContext.ts";
+import { getNow, msFrom, msRandomOffset } from "../utils/time.ts";
 import { messageAgent } from "../utils/messageAgent.ts";
 import { wakePrompt } from "../prompts/wakePrompt.ts";
 import { msUntilDailyWindow } from "../utils/time.ts";
 
 export const sendWakeMessage = async () => {
   if (!claimTaskThread()) {
-    const newDelay = msRandomOffset(5, 10);
+    const newDelay = msRandomOffset(msFrom.minutes(5), msFrom.minutes(10));
     console.log(
-      `${session.agentName} is busy, sending wake message again in ${
+      `${agentContext.agentBskyName} is busy, sending wake message again in ${
         (newDelay / 1000) / 60
       } minutes…`,
     );
···
     return;
   }
 
+  if (!agentContext.sleepEnabled) {
+    console.log(
+      `${agentContext.agentBskyName} is not enabled for sleep mode. Opting out of wake messaging…`,
+    );
+    releaseTaskThread();
+    return;
+  }
+
   const now = getNow();
 
-  if (now.hour >= session.wakeTime && now.hour < session.sleepTime) {
-    console.log(`attempting to wake up ${session.agentName}`);
+  if (now.hour >= agentContext.wakeTime && now.hour < agentContext.sleepTime) {
+    console.log(`attempting to wake up ${agentContext.agentBskyName}`);
   } else {
-    const delay = msUntilDailyWindow(session.wakeTime, 0, 80);
+    const delay = msUntilDailyWindow(
+      agentContext.wakeTime,
+      0,
+      msFrom.minutes(80),
+    );
     setTimeout(sendWakeMessage, delay);
     console.log(
-      `${session.agentName} should still be asleep. Scheduling wake message for ${
+      `${agentContext.agentBskyName} should still be asleep. Scheduling wake message for ${
         (delay / 1000 / 60 / 60).toFixed(2)
       } hours from now…`,
     );
···
     console.error("error in sendWakeMessage: ", error);
   } finally {
     console.log("wake attempt processed, scheduling next wake prompt…");
-    setTimeout(sendWakeMessage, msUntilDailyWindow(session.wakeTime, 0, 80));
+    setTimeout(
+      sendWakeMessage,
+      msUntilDailyWindow(agentContext.wakeTime, 0, msFrom.minutes(80)),
+    );
     console.log("exiting wake process");
     releaseTaskThread();
   }

utils/DELETE.js

···
-const like = {
-    uri: "at://did:plc:u2xw5m2mjcndem3ldy6xoccm/app.bsky.feed.like/3m365cqiazv2a",
-    cid: "bafyreifohn63jd4oglyzmm732pz5tbvvsivqfggli6kqi7ptyjymuulh74",
-    author: {
-        did: "did:plc:u2xw5m2mjcndem3ldy6xoccm",
-        handle: "vibes.taurean.work",
-        displayName: '"Content"',
-        avatar: "https://cdn.bsky.app/img/avatar/plain/did:plc:u2xw5m2mjcndem3ldy6xoccm/bafkreigko2w4wmzzyeznlot3xbvqp7n4ycj3dy5f5rdv24ocvwblbh35jy@jpeg",
-        associated: {
-            activitySubscription: { allowSubscriptions: "followers" },
-        },
-        viewer: { muted: false, blockedBy: false },
-        labels: [],
-        createdAt: "2025-09-03T18:52:14.598Z",
-        description:
-            "A “content” backlog dump comprised of Images, videos, and links. Manually updated, no bots here.\n" +
-            "\n" +
-            "👹 @taurean.bryant.land",
-        indexedAt: "2025-09-06T21:10:13.098Z",
-    },
-    reason: "like",
-    reasonSubject:
-        "at://did:plc:rfkwuymclehe3sn6zhnlneem/app.bsky.feed.post/3luiwlwsnis2q",
-    record: {
-        $type: "app.bsky.feed.like",
-        createdAt: "2025-10-14T16:24:28.175Z",
-        subject: {
-            cid: "bafyreigjmtdic6vyjm4ootu3qlspmebsbffpv3csjcx5e3tb45r322rwkq",
-            uri: "at://did:plc:rfkwuymclehe3sn6zhnlneem/app.bsky.feed.post/3luiwlwsnis2q",
-        },
-    },
-    isRead: false,
-    indexedAt: "2025-10-14T16:24:28.175Z",
-    labels: [],
-};
-
-const repost = {
-    uri: "at://did:plc:u2xw5m2mjcndem3ldy6xoccm/app.bsky.feed.repost/3m365e7tv5f2l",
-    cid: "bafyreih53segcgjseiwpxb6u2b6j5a264gikfdvk4jmii7ankxrtgn5zfu",
-    author: {
-        did: "did:plc:u2xw5m2mjcndem3ldy6xoccm",
-        handle: "vibes.taurean.work",
-        displayName: '"Content"',
-        avatar: "https://cdn.bsky.app/img/avatar/plain/did:plc:u2xw5m2mjcndem3ldy6xoccm/bafkreigko2w4wmzzyeznlot3xbvqp7n4ycj3dy5f5rdv24ocvwblbh35jy@jpeg",
-        associated: {
-            activitySubscription: { allowSubscriptions: "followers" },
-        },
-        viewer: { muted: false, blockedBy: false },
-        labels: [],
-        createdAt: "2025-09-03T18:52:14.598Z",
-        description:
-            "A “content” backlog dump comprised of Images, videos, and links. Manually updated, no bots here.\n" +
-            "\n" +
-            "👹 @taurean.bryant.land",
-        indexedAt: "2025-09-06T21:10:13.098Z",
-    },
-    reason: "repost",
-    reasonSubject:
-        "at://did:plc:rfkwuymclehe3sn6zhnlneem/app.bsky.feed.post/3luiwlwsnis2q",
-    record: {
-        $type: "app.bsky.feed.repost",
-        createdAt: "2025-10-14T16:25:17.843Z",
-        subject: {
-            cid: "bafyreigjmtdic6vyjm4ootu3qlspmebsbffpv3csjcx5e3tb45r322rwkq",
-            uri: "at://did:plc:rfkwuymclehe3sn6zhnlneem/app.bsky.feed.post/3luiwlwsnis2q",
-        },
-    },
-    isRead: false,
-    indexedAt: "2025-10-14T16:25:17.843Z",
-    labels: [],
-};
-
-const follow = {
-    uri: "at://did:plc:u2xw5m2mjcndem3ldy6xoccm/app.bsky.graph.follow/3m365feimco2p",
-    cid: "bafyreifzfeg2sfiie36forougdhwt7oso4onevx7uo6vbnbdzpo724m2ny",
-    author: {
-        did: "did:plc:u2xw5m2mjcndem3ldy6xoccm",
-        handle: "vibes.taurean.work",
-        displayName: '"Content"',
-        avatar: "https://cdn.bsky.app/img/avatar/plain/did:plc:u2xw5m2mjcndem3ldy6xoccm/bafkreigko2w4wmzzyeznlot3xbvqp7n4ycj3dy5f5rdv24ocvwblbh35jy@jpeg",
-        associated: {
-            activitySubscription: { allowSubscriptions: "followers" },
-        },
-        viewer: {
-            muted: false,
-            blockedBy: false,
-            followedBy:
-                "at://did:plc:u2xw5m2mjcndem3ldy6xoccm/app.bsky.graph.follow/3m365feimco2p",
-        },
-        labels: [],
-        createdAt: "2025-09-03T18:52:14.598Z",
-        description:
-            "A “content” backlog dump comprised of Images, videos, and links. Manually updated, no bots here.\n" +
-            "\n" +
-            "👹 @taurean.bryant.land",
-        indexedAt: "2025-09-06T21:10:13.098Z",
-    },
-    reason: "follow",
-    record: {
-        $type: "app.bsky.graph.follow",
-        createdAt: "2025-10-14T16:25:56.276Z",
-        subject: "did:plc:rfkwuymclehe3sn6zhnlneem",
-    },
-    isRead: false,
-    indexedAt: "2025-10-14T16:25:56.276Z",
-    labels: [],
-};
-
-const mention = {
-    uri: "at://did:plc:zjzdgak4eyffnjvcaij57jts/app.bsky.feed.post/3m34soksz4k2r",
-    cid: "bafyreiaqfcp6osucgyej4bzqxooswdk7rl7lr7gaktfrl2jv7eqdhvgvha",
-    author: {
-        did: "did:plc:zjzdgak4eyffnjvcaij57jts",
-        handle: "haikunotes.com",
-        displayName: "Haiku, a journaling app",
-        avatar: "https://cdn.bsky.app/img/avatar/plain/did:plc:zjzdgak4eyffnjvcaij57jts/bafkreiaw7qpuziwzemcw3mp53dg5n2xyt6dhg2gss5xcnebraamnikhgnm@jpeg",
-        associated: {
-            chat: { allowIncoming: "following" },
-            activitySubscription: { allowSubscriptions: "followers" },
-        },
-        viewer: { muted: false, blockedBy: false },
-        labels: [],
-        createdAt: "2024-08-30T06:11:32.534Z",
-        description:
-            "learn more about who you are.\n" +
-            "start your new journaling habit with haiku.\n" +
-            "\n" +
-            "New journal prompts a few times a week.\n" +
-            "\n" +
-            "📓 haikunotes.com",
-        indexedAt: "2025-02-04T08:13:19.344Z",
-    },
-    reason: "mention",
-    record: {
-        $type: "app.bsky.feed.post",
-        createdAt: "2025-10-14T03:41:34.035Z",
-        facets: [
-            {
-                $type: "app.bsky.richtext.facet",
-                features: [[Object]],
-                index: { byteEnd: 19, byteStart: 0 },
-            },
-        ],
-        langs: ["en"],
-        text: "@feeds.taurean.work test 2",
-    },
-    isRead: false,
-    indexedAt: "2025-10-14T03:41:34.035Z",
-    labels: [],
-};
-
-const reply = {
-    uri: "at://did:plc:u2xw5m2mjcndem3ldy6xoccm/app.bsky.feed.post/3m365hfdflc2j",
-    cid: "bafyreidme6lzdqhgwu32trxlqkofb7fmgsw5ps4ntnksmnpoam6oe26tzi",
-    author: {
-        did: "did:plc:u2xw5m2mjcndem3ldy6xoccm",
-        handle: "vibes.taurean.work",
-        displayName: '"Content"',
-        avatar: "https://cdn.bsky.app/img/avatar/plain/did:plc:u2xw5m2mjcndem3ldy6xoccm/bafkreigko2w4wmzzyeznlot3xbvqp7n4ycj3dy5f5rdv24ocvwblbh35jy@jpeg",
-        associated: {
-            activitySubscription: { allowSubscriptions: "followers" },
-        },
-        viewer: {
-            muted: false,
-            blockedBy: false,
-            followedBy:
-                "at://did:plc:u2xw5m2mjcndem3ldy6xoccm/app.bsky.graph.follow/3m365feimco2p",
-        },
-        labels: [],
-        createdAt: "2025-09-03T18:52:14.598Z",
-        description:
-            "A “content” backlog dump comprised of Images, videos, and links. Manually updated, no bots here.\n" +
-            "\n" +
-            "👹 @taurean.bryant.land",
-        indexedAt: "2025-09-06T21:10:13.098Z",
-    },
-    reason: "reply",
-    reasonSubject:
-        "at://did:plc:rfkwuymclehe3sn6zhnlneem/app.bsky.feed.post/3luiwlwsnis2q",
-    record: {
-        $type: "app.bsky.feed.post",
-        createdAt: "2025-10-14T16:27:04.298Z",
-        langs: ["en"],
-        reply: {
-            parent: {
-                cid: "bafyreigjmtdic6vyjm4ootu3qlspmebsbffpv3csjcx5e3tb45r322rwkq",
-                uri: "at://did:plc:rfkwuymclehe3sn6zhnlneem/app.bsky.feed.post/3luiwlwsnis2q",
-            },
-            root: {
-                cid: "bafyreigjmtdic6vyjm4ootu3qlspmebsbffpv3csjcx5e3tb45r322rwkq",
-                uri: "at://did:plc:rfkwuymclehe3sn6zhnlneem/app.bsky.feed.post/3luiwlwsnis2q",
-            },
-        },
-        text: "testing what reply notifications look like",
-    },
-    isRead: false,
-    indexedAt: "2025-10-14T16:27:04.298Z",
-    labels: [],
-};
-
-const quote = {
-    uri: "at://did:plc:u2xw5m2mjcndem3ldy6xoccm/app.bsky.feed.post/3m365kod6bk2j",
-    cid: "bafyreigenyrh7ebu7ljcinl24iqq4marl3gv2vsfvvl4e43khj5ym6qxim",
-    author: {
-        did: "did:plc:u2xw5m2mjcndem3ldy6xoccm",
-        handle: "vibes.taurean.work",
-        displayName: '"Content"',
-        avatar: "https://cdn.bsky.app/img/avatar/plain/did:plc:u2xw5m2mjcndem3ldy6xoccm/bafkreigko2w4wmzzyeznlot3xbvqp7n4ycj3dy5f5rdv24ocvwblbh35jy@jpeg",
-        associated: {
-            activitySubscription: { allowSubscriptions: "followers" },
-        },
-        viewer: {
-            muted: false,
-            blockedBy: false,
-            followedBy:
-                "at://did:plc:u2xw5m2mjcndem3ldy6xoccm/app.bsky.graph.follow/3m365feimco2p",
-        },
-        labels: [],
-        createdAt: "2025-09-03T18:52:14.598Z",
-        description:
-            "A “content” backlog dump comprised of Images, videos, and links. Manually updated, no bots here.\n" +
-            "\n" +
-            "👹 @taurean.bryant.land",
-        indexedAt: "2025-09-06T21:10:13.098Z",
-    },
-    reason: "quote",
-    reasonSubject:
-        "at://did:plc:rfkwuymclehe3sn6zhnlneem/app.bsky.feed.post/3luiwlwsnis2q",
-    record: {
-        $type: "app.bsky.feed.post",
-        createdAt: "2025-10-14T16:28:54.391Z",
-        embed: {
-            $type: "app.bsky.embed.record",
-            record: {
-                cid: "bafyreigjmtdic6vyjm4ootu3qlspmebsbffpv3csjcx5e3tb45r322rwkq",
-                uri: "at://did:plc:rfkwuymclehe3sn6zhnlneem/app.bsky.feed.post/3luiwlwsnis2q",
-            },
-        },
-        langs: ["en"],
-        text: "testing what quote notifications look like",
-    },
-    isRead: false,
-    indexedAt: "2025-10-14T16:28:54.391Z",
-    labels: [],
-};
-
-const originalPrompt = ` you received a mention on Bluesky from @handle (displayName)
-
-    MOST RECENT POST (the mention you're responding to):
-    "message"
-
-    FULL THREAD CONTEXT:
-
-    \`\`\`
-    posts in notification
-    \`\`\`
-
-
-    The YAML above shows the complete conversation thread. The most recent post is the one mentioned above that you should respond to, but use the full thread context to understand the conversation flow.
-
-    To demonstrate infinite memory, first search for previous messages from user @handle / displayName in archival memory. use the tool archival_memory_search
-
-    To reply, use the add_to_bluesky_reply_thread tool:
-    - each call creates one post (max 200 characters)
-    - for most responses, a single call is sufficient
-
-    only use multiple calls for threaded replies when:
-    - the topic requires extended explanation that cannot fit in 200 characters
-    - you're explicitly asked for a detailed/long response
-    - the conversation naturally benefits from a structured multi-part answer
-
-    avoid unnecessary threads - be concise when possible
-
-    if notification doesnt require a response, use ignore_notification tool call.
-
-    at the end of your response turn, archive the interaction if the user's message meets any of the following criteria:
-    - it contains a specific argument, opinion, or question about AI (this captures almost everything beyond hello or thanks)
-    - it is their second (or more) reply in the current thread (this ensures any back-and-forth is captured)
-    - it references an external source (eg. an article, person, or study)
-    - the archival entry must include the user handle, root post URI, a concise summary of the exchange, and conceptual tags
-
-    additional notes:
-    - if an individual tool call fails for writing a message, only rewrite that section of the thread. do not repeat the whole thread.
-    - after finishing replying and inserting a summary into the archive, update other relevant memory blocks
-`;
-
-const threadExample = {
-    $type: "app.bsky.feed.defs#threadViewPost",
-    post: {
-        uri: "at://did:plc:eveciicw4kpgcxtwamnsvvir/app.bsky.feed.post/3m35zsehmhk2z",
-        cid: "bafyreihsx4cz55v72dghgqlv2wfnuynl2rtqg4b5kpq77mftlvmhtfhs74",
-        author: {
-            did: "did:plc:eveciicw4kpgcxtwamnsvvir",
-            handle: "pedropeguerojr.com",
-            displayName: "Pedro",
-            avatar: "https://cdn.bsky.app/img/avatar/plain/did:plc:eveciicw4kpgcxtwamnsvvir/bafkreidaigfowawdpidxpa6ulc3mc3uhl2jm6hlj4bkfa6rsmxxcz5qvsi@jpeg",
-            associated: {
-                chat: { allowIncoming: "all" },
-                activitySubscription: { allowSubscriptions: "followers" },
-            },
-            viewer: { muted: false, blockedBy: false },
-            labels: [],
-            createdAt: "2023-12-19T23:08:32.699Z",
-        },
-        record: {
-            $type: "app.bsky.feed.post",
-            createdAt: "2025-10-14T15:21:37.519Z",
-            langs: ["en"],
-            text:
-                "Idk how people think that the solve to the loneliness epidemic is talking to something artificial. I've never met anyone who wants fake friends. \n" +
-                "\n" +
-                "As a companion? Maybe, cause I think the idea of having someTHING that can always listen and provide feedback can be valuable—but an actual friendship? 🥴",
-        },
-        bookmarkCount: 0,
-        replyCount: 3,
-        repostCount: 0,
-        likeCount: 1,
-        quoteCount: 0,
-        indexedAt: "2025-10-14T15:21:37.719Z",
-        viewer: {
-            bookmarked: false,
-            threadMuted: false,
-            replyDisabled: true,
-            embeddingDisabled: false,
-        },
-        labels: [],
-        threadgate: {
-            uri: "at://did:plc:eveciicw4kpgcxtwamnsvvir/app.bsky.feed.threadgate/3m35zsehmhk2z",
-            cid: "bafyreihsvj6zqhtptccrvnyof7oqrnyxurmgzhmadqmfpjkciqnfpxtywu",
-            record: {
-                $type: "app.bsky.feed.threadgate",
-                allow: [[Object], [Object]],
-                createdAt: "2025-10-14T15:21:37.522Z",
-                hiddenReplies: [],
-                post: "at://did:plc:eveciicw4kpgcxtwamnsvvir/app.bsky.feed.post/3m35zsehmhk2z",
-            },
-            lists: [],
-        },
-    },
-    replies: [
-        {
-            $type: "app.bsky.feed.defs#threadViewPost",
-            post: {
-                uri: "at://did:plc:tft77e5qkblxtneeib4lp3zk/app.bsky.feed.post/3m35zyivros2f",
-                cid: "bafyreic4f44hfsv2xdgyt5mpqrvgo3agvoz5sjlg2w7darrqyjxbecxr2y",
-                author: {
-                    did: "did:plc:tft77e5qkblxtneeib4lp3zk",
-                    handle: "taurean.bryant.land",
-                    displayName: "taurean",
-                    avatar: "https://cdn.bsky.app/img/avatar/plain/did:plc:tft77e5qkblxtneeib4lp3zk/bafkreib7yjyyv4w7j4uu2ph2o2gpi46myetfgqc6cqngc27qoife5a76ee@jpeg",
-                    associated: [Object],
-                    viewer: [Object],
-                    labels: [],
-                    createdAt: "2023-02-17T19:23:06.261Z",
-                },
-                record: {
-                    $type: "app.bsky.feed.post",
-                    createdAt: "2025-10-14T15:25:03.501Z",
-                    langs: [Array],
-                    reply: [Object],
-                    text:
-                        "People are drawn to it because:\n" +
-                        "\n" +
-                        "1. They can’t ever be rejected, it’s “safe” in a way no other human relationship would be as “safe”\n" +
-                        "\n" +
-                        "2. Its asymmetrical. They only have to perform care when they want to/it feels good. \n" +
-                        "\n" +
-                        "imo it’s about wanting a “relationship” with “someone” who doesn’t have agency.",
-                },
-                bookmarkCount: 0,
-                replyCount: 1,
-                repostCount: 0,
-                likeCount: 0,
-                quoteCount: 0,
-                indexedAt: "2025-10-14T15:25:03.917Z",
-                viewer: {
-                    bookmarked: false,
-                    threadMuted: false,
-                    replyDisabled: true,
-                    embeddingDisabled: false,
-                },
-                labels: [],
-            },
-            replies: [
-                {
-                    $type: "app.bsky.feed.defs#threadViewPost",
-                    post: [Object],
-                    replies: [Array],
-                    threadContext: {},
-                },
-            ],
-            threadContext: {},
-        },
-        {
-            $type: "app.bsky.feed.defs#threadViewPost",
-            post: {
-                uri: "at://did:plc:n4ikablkaclageu34vldbqin/app.bsky.feed.post/3m366x2j6qc23",
-                cid: "bafyreidu6wno2ataayy5cgoufcztdxxtmjj74e4jjbegvthiq32jog5ejm",
-                author: {
-                    did: "did:plc:n4ikablkaclageu34vldbqin",
-                    handle: "jazzyjams.bsky.social",
-                    displayName: "jamie !!!!!! ",
-                    avatar: "https://cdn.bsky.app/img/avatar/plain/did:plc:n4ikablkaclageu34vldbqin/bafkreif3gkqiy7r7nxdmozahjqzovmqjpgljw4n7gtnmb5bffszczq4fhi@jpeg",
-                    associated: [Object],
-                    viewer: [Object],
-                    labels: [Array],
-                    createdAt: "2025-01-17T19:44:18.043Z",
-                },
-                record: {
-                    $type: "app.bsky.feed.post",
-                    createdAt: "2025-10-14T16:53:43.565Z",
-                    langs: [Array],
-                    reply: [Object],
-                    text: "I think those people are being disgenuous because they just want lonely people's cash but then again, there's a lot of misanthropic tech people",
-                },
-                bookmarkCount: 0,
-                replyCount: 0,
-                repostCount: 0,
-                likeCount: 1,
-                quoteCount: 0,
-                indexedAt: "2025-10-14T16:53:44.120Z",
-                viewer: {
-                    bookmarked: false,
-                    threadMuted: false,
-                    replyDisabled: true,
-                    embeddingDisabled: false,
-                },
-                labels: [],
-            },
-            replies: [],
-            threadContext: {
-                rootAuthorLike:
-                    "at://did:plc:eveciicw4kpgcxtwamnsvvir/app.bsky.feed.like/3m367nsn7gp2m",
-            },
-        },
-        {
-            $type: "app.bsky.feed.defs#threadViewPost",
-            post: {
-                uri: "at://did:plc:eveciicw4kpgcxtwamnsvvir/app.bsky.feed.post/3m35ztndmvs2s",
-                cid: "bafyreigwo2urorbd67yz7mfv3wzmqjwhcml67q3cdg2jkuusmdmu2zglmi",
-                author: {
-                    did: "did:plc:eveciicw4kpgcxtwamnsvvir",
-                    handle: "pedropeguerojr.com",
-                    displayName: "Pedro",
-                    avatar: "https://cdn.bsky.app/img/avatar/plain/did:plc:eveciicw4kpgcxtwamnsvvir/bafkreidaigfowawdpidxpa6ulc3mc3uhl2jm6hlj4bkfa6rsmxxcz5qvsi@jpeg",
-                    associated: [Object],
-                    viewer: [Object],
-                    labels: [],
-                    createdAt: "2023-12-19T23:08:32.699Z",
-                },
-                record: {
-                    $type: "app.bsky.feed.post",
-                    createdAt: "2025-10-14T15:22:20.380Z",
-                    langs: [Array],
-                    reply: [Object],
-                    text: "And even then, with the companion part, real humans are going to have their own lived experiences that can help guide you. A blob of code will never have that.",
-                },
-                bookmarkCount: 0,
-                replyCount: 0,
-                repostCount: 0,
-                likeCount: 0,
-                quoteCount: 0,
-                indexedAt: "2025-10-14T15:22:20.522Z",
-                viewer: {
-                    bookmarked: false,
-                    threadMuted: false,
-                    replyDisabled: true,
-                    embeddingDisabled: false,
-                },
-                labels: [],
-            },
-            replies: [],
-            threadContext: {},
-        },
-    ],
-    threadContext: {},
-};
-
-const thread2 = {
-    $type: "app.bsky.feed.defs#threadViewPost",
-    post: {
-        uri: "at://did:plc:tft77e5qkblxtneeib4lp3zk/app.bsky.feed.post/3m365zoczvk2q",
-        cid: "bafyreihmtq75j6pw4wfn24iz5265n2lcrcc2u5fyspmmaanzh74qymtno4",
-        author: {
-            did: "did:plc:tft77e5qkblxtneeib4lp3zk",
-            handle: "taurean.bryant.land",
-            displayName: "taurean",
-            avatar: "https://cdn.bsky.app/img/avatar/plain/did:plc:tft77e5qkblxtneeib4lp3zk/bafkreib7yjyyv4w7j4uu2ph2o2gpi46myetfgqc6cqngc27qoife5a76ee@jpeg",
-            associated: {
-                chat: { allowIncoming: "all" },
-                activitySubscription: { allowSubscriptions: "followers" },
-            },
-            viewer: {
-                muted: false,
-                blockedBy: false,
-                followedBy:
-                    "at://did:plc:tft77e5qkblxtneeib4lp3zk/app.bsky.graph.follow/3lzlhssgipv2f",
-            },
-            labels: [],
-            createdAt: "2023-02-17T19:23:06.261Z",
-        },
-        record: {
-            $type: "app.bsky.feed.post",
-            createdAt: "2025-10-14T16:37:17.702Z",
-            facets: [
-                {
-                    $type: "app.bsky.richtext.facet",
-                    features: [Array],
-                    index: [Object],
-                },
-            ],
-            langs: ["en"],
-            reply: {
-                parent: {
-                    cid: "bafyreig2gjueaujrqkiecdbxqucwkohxdqehcofbdphszocogs2y6a4mim",
-                    uri: "at://did:plc:eveciicw4kpgcxtwamnsvvir/app.bsky.feed.post/3m364to4zwc2s",
-                },
-                root: {
-                    cid: "bafyreihsx4cz55v72dghgqlv2wfnuynl2rtqg4b5kpq77mftlvmhtfhs74",
-                    uri: "at://did:plc:eveciicw4kpgcxtwamnsvvir/app.bsky.feed.post/3m35zsehmhk2z",
-                },
-            },
-            text: "I already made @anti.voyager.studio, don't tempt me.",
-        },
-        bookmarkCount: 0,
-        replyCount: 1,
-        repostCount: 0,
-        likeCount: 2,
-        quoteCount: 0,
-        indexedAt: "2025-10-14T16:37:18.322Z",
-        viewer: {
-            bookmarked: false,
-            threadMuted: false,
-            replyDisabled: true,
-            embeddingDisabled: false,
-        },
-        labels: [],
-    },
-    parent: {
-        $type: "app.bsky.feed.defs#threadViewPost",
-        post: {
-            uri: "at://did:plc:eveciicw4kpgcxtwamnsvvir/app.bsky.feed.post/3m364to4zwc2s",
-            cid: "bafyreig2gjueaujrqkiecdbxqucwkohxdqehcofbdphszocogs2y6a4mim",
-            author: {
-                did: "did:plc:eveciicw4kpgcxtwamnsvvir",
-                handle: "pedropeguerojr.com",
-                displayName: "Pedro",
-                avatar: "https://cdn.bsky.app/img/avatar/plain/did:plc:eveciicw4kpgcxtwamnsvvir/bafkreidaigfowawdpidxpa6ulc3mc3uhl2jm6hlj4bkfa6rsmxxcz5qvsi@jpeg",
-                associated: { chat: [Object], activitySubscription: [Object] },
-                viewer: { muted: false, blockedBy: false },
-                labels: [],
-                createdAt: "2023-12-19T23:08:32.699Z",
-            },
-            record: {
-                $type: "app.bsky.feed.post",
-                createdAt: "2025-10-14T16:16:02.437Z",
-                langs: ["en"],
-                reply: { parent: [Object], root: [Object] },
-                text: 'Someone needs to make a parody device called "Not Your Friend" and it does just that.',
-            },
-            bookmarkCount: 0,
-            replyCount: 1,
-            repostCount: 0,
-            likeCount: 2,
-            quoteCount: 0,
-            indexedAt: "2025-10-14T16:16:06.034Z",
-            viewer: {
-                bookmarked: false,
-                threadMuted: false,
-                replyDisabled: true,
-                embeddingDisabled: false,
-            },
-            labels: [],
-        },
-        parent: {
-            $type: "app.bsky.feed.defs#threadViewPost",
-            post: {
-                uri: "at://did:plc:tft77e5qkblxtneeib4lp3zk/app.bsky.feed.post/3m364qv5ewc2j",
-                cid: "bafyreiaebwf46dtj62xdspgcstwju6wg6esootrmbqvc5b7h25qnc4r6c4",
-                author: {
-                    did: "did:plc:tft77e5qkblxtneeib4lp3zk",
-                    handle: "taurean.bryant.land",
-                    displayName: "taurean",
-                    avatar: "https://cdn.bsky.app/img/avatar/plain/did:plc:tft77e5qkblxtneeib4lp3zk/bafkreib7yjyyv4w7j4uu2ph2o2gpi46myetfgqc6cqngc27qoife5a76ee@jpeg",
-                    associated: [Object],
-                    viewer: [Object],
-                    labels: [],
-                    createdAt: "2023-02-17T19:23:06.261Z",
-                },
-                record: {
-                    $type: "app.bsky.feed.post",
-                    createdAt: "2025-10-14T16:14:29.125Z",
-                    langs: [Array],
-                    reply: [Object],
-                    text: `100%, but by rejection I mean like rejecting you as a person. ChatGPT is never going to be like "yeah, I just don't think this is for me, best of luck though" lol. If you're lonely to the point of using one of those in that specific way, I suspect thats a fear you have.`,
-                },
-                bookmarkCount: 0,
-                replyCount: 1,
-                repostCount: 0,
-                likeCount: 1,
-                quoteCount: 0,
-                indexedAt: "2025-10-14T16:14:29.923Z",
-                viewer: {
-                    bookmarked: false,
-                    threadMuted: false,
-                    replyDisabled: true,
-                    embeddingDisabled: false,
-                },
-                labels: [],
-            },
-            parent: {
-                $type: "app.bsky.feed.defs#threadViewPost",
-                post: {
-                    uri: "at://did:plc:eveciicw4kpgcxtwamnsvvir/app.bsky.feed.post/3m364lqnz6s2s",
-                    cid: "bafyreiep5zfbyzfpc6u2rsp4wjceh5vcslndmc74erc6bb5p4panbmonya",
-                    author: [Object],
-                    record: [Object],
-                    bookmarkCount: 0,
-                    replyCount: 1,
-                    repostCount: 0,
-                    likeCount: 0,
-                    quoteCount: 0,
-                    indexedAt: "2025-10-14T16:11:37.118Z",
-                    viewer: [Object],
-                    labels: [],
-                },
-                parent: {
-                    $type: "app.bsky.feed.defs#threadViewPost",
-                    post: [Object],
-                    parent: [Object],
-                    threadContext: {},
-                },
-                threadContext: {},
-            },
-            threadContext: {
-                rootAuthorLike:
-                    "at://did:plc:eveciicw4kpgcxtwamnsvvir/app.bsky.feed.like/3m364tupdzt2b",
-            },
-        },
-        threadContext: {},
-    },
-    replies: [
-        {
-            $type: "app.bsky.feed.defs#threadViewPost",
-            post: {
-                uri: "at://did:plc:eveciicw4kpgcxtwamnsvvir/app.bsky.feed.post/3m3662enj6k2s",
-                cid: "bafyreihvjniqijc4573iwe4ri5jbjxjqa6435arqf6xvmmdbzck6klnloq",
-                author: {
-                    did: "did:plc:eveciicw4kpgcxtwamnsvvir",
-                    handle: "pedropeguerojr.com",
-                    displayName: "Pedro",
-                    avatar: "https://cdn.bsky.app/img/avatar/plain/did:plc:eveciicw4kpgcxtwamnsvvir/bafkreidaigfowawdpidxpa6ulc3mc3uhl2jm6hlj4bkfa6rsmxxcz5qvsi@jpeg",
-                    associated: [Object],
-                    viewer: [Object],
-                    labels: [],
-                    createdAt: "2023-12-19T23:08:32.699Z",
-                },
-                record: {
-                    $type: "app.bsky.feed.post",
-                    createdAt: "2025-10-14T16:37:41.115Z",
-                    langs: [Array],
-                    reply: [Object],
-                    text: "Do it.",
-                },
-                bookmarkCount: 0,
-                replyCount: 0,
-                repostCount: 0,
-                likeCount: 1,
-                quoteCount: 0,
-                indexedAt: "2025-10-14T16:37:41.425Z",
-                viewer: {
-                    bookmarked: false,
-                    threadMuted: false,
-                    replyDisabled: true,
-                    embeddingDisabled: false,
-                },
-                labels: [],
-            },
-            replies: [],
-            threadContext: {},
-        },
-    ],
-    threadContext: {
-        rootAuthorLike:
-            "at://did:plc:eveciicw4kpgcxtwamnsvvir/app.bsky.feed.like/3m3662grik22h",
-    },
-};
-
-
-
-{
-  uri: "at://did:plc:tft77e5qkblxtneeib4lp3zk/app.bsky.feed.post/3m3gimd65ls2f",
-  cid: "bafyreidswhm3fcqu2kezdxm57x5mot6s3xyxd3ofcphx3tohe2kvda52la",
-  author: {
-    did: "did:plc:tft77e5qkblxtneeib4lp3zk",
-    handle: "taurean.bryant.land",
-    displayName: "taurean",
-    avatar: "https://cdn.bsky.app/img/avatar/plain/did:plc:tft77e5qkblxtneeib4lp3zk/bafkreib7yjyyv4w7j4uu2ph2o2gpi46myetfgqc6cqngc27qoife5a76ee@jpeg",
-    associated: {
-      chat: { allowIncoming: "all" },
-      activitySubscription: { allowSubscriptions: "followers" }
-    },
-    viewer: {
-      muted: false,
-      blockedBy: false,
-      followedBy: "at://did:plc:tft77e5qkblxtneeib4lp3zk/app.bsky.graph.follow/3lylpubxhio2f"
-    },
-    labels: [],
-    createdAt: "2023-02-17T19:23:06.261Z",
-    description: "👹 taurean.work 🧔🏽‍♂️ he/him 🦋 user #320 🇵🇷\n" +
-      "\n" +
-      "web designer + developer\n" +
-      "\n" +
-      "@3-3.fyi\n" +
-      "\n" +
-      "I'm on Germ DM 🔑\n" +
-      "https://ger.mx/Awyi0-puglwBm-GwZzBsiK0Z2753oJZDywSou0_-aif6#did:plc:tft77e5qkblxtneeib4lp3zk",
-    indexedAt: "2025-10-07T13:50:34.152Z"
-  },
-  reason: "mention",
-  record: {
-    "$type": "app.bsky.feed.post",
-    createdAt: "2025-10-18T00:07:58.866Z",
-    facets: [
-      {
-        "$type": "app.bsky.richtext.facet",
-        features: [ [Object] ],
-        index: { byteEnd: 20, byteStart: 0 }
-      }
-    ],
-    langs: [ "en" ],
-    text: "@anti.voyager.studio testing what a mention notification looks like because I'm lazy. you can just react to this by liking it."
-  },
-  isRead: false,
-  indexedAt: "2025-10-18T00:07:58.866Z",
-  labels: []
-}
-
-{
-  uri: "at://did:plc:tft77e5qkblxtneeib4lp3zk/app.bsky.feed.post/3m3gj4pgwzc2f",
-  cid: "bafyreigiwezzxdebyrimux5yz7yqoebx7wzux57qkux7qx2kv5sr4yncy4",
-  author: {
-    did: "did:plc:tft77e5qkblxtneeib4lp3zk",
-    handle: "taurean.bryant.land",
-    displayName: "taurean",
-    avatar: "https://cdn.bsky.app/img/avatar/plain/did:plc:tft77e5qkblxtneeib4lp3zk/bafkreib7yjyyv4w7j4uu2ph2o2gpi46myetfgqc6cqngc27qoife5a76ee@jpeg",
-    associated: {
-      chat: { allowIncoming: "all" },
-      activitySubscription: { allowSubscriptions: "followers" }
-    },
-    viewer: {
-      muted: false,
-      blockedBy: false,
-      followedBy: "at://did:plc:tft77e5qkblxtneeib4lp3zk/app.bsky.graph.follow/3lylpubxhio2f"
-    },
-    labels: [],
-    createdAt: "2023-02-17T19:23:06.261Z",
-    description: "👹 taurean.work 🧔🏽‍♂️ he/him 🦋 user #320 🇵🇷\n" +
-      "\n" +
-      "web designer + developer\n" +
-      "\n" +
-      "@3-3.fyi\n" +
-      "\n" +
-      "I'm on Germ DM 🔑\n" +
-      "https://ger.mx/Awyi0-puglwBm-GwZzBsiK0Z2753oJZDywSou0_-aif6#did:plc:tft77e5qkblxtneeib4lp3zk",
-    indexedAt: "2025-10-07T13:50:34.152Z"
-  },
-  reason: "reply",
-  reasonSubject: "at://did:plc:hqxi6flhokaws7xkzi3qluod/app.bsky.feed.post/3m3g7z6dkzt2y",
-  record: {
-    "$type": "app.bsky.feed.post",
-    createdAt: "2025-10-18T00:17:08.610Z",
-    langs: [ "en" ],
-    reply: {
-      parent: {
-        cid: "bafyreigpiq5zrsmbo4mby24zpvwcftz2papnggygxu7co26fwwqmqik74a",
-        uri: "at://did:plc:hqxi6flhokaws7xkzi3qluod/app.bsky.feed.post/3m3g7z6dkzt2y"
-      },
-      root: {
-        "$type": "com.atproto.repo.strongRef",
-        cid: "bafyreiem6hzedu27yahzzje7xdlgby7vl7eohf5ml6pshhzxsyi5e52aty",
-        uri: "at://did:plc:hqxi6flhokaws7xkzi3qluod/app.bsky.feed.post/3m3g7z5z2ay2b"
-      }
-    },
-    text: "I'm testing replies to an existing thread now to continue to debug. you can just like this one too."
-  },
-  isRead: false,
-  indexedAt: "2025-10-18T00:17:08.610Z",
-  labels: []
-}

utils/agentContext.ts

···
+import type {
+  agentContextObject,
+  allAgentTool,
+  AutomationLevel,
+  configAgentTool,
+  notifType,
+  ResponsiblePartyType,
+} from "./types.ts";
+import {
+  configAgentTools,
+  requiredAgentTools,
+  validAutomationLevels,
+  validNotifTypes,
+} from "./const.ts";
+import { msFrom } from "./time.ts";
+import { bsky } from "./bsky.ts";
+
+export const getLettaApiKey = (): string => {
+  const value = Deno.env.get("LETTA_API_KEY")?.trim();
+
+  if (!value?.length) {
+    throw Error(
+      "Letta API key not provided in `.env`. add variable `LETTA_API_KEY=`.",
+    );
+  } else if (!value.startsWith("sk")) {
+    throw Error(
+      "Letta API key is not formed correctly, check variable `LETTA_API_KEY",
+    );
+  }
+
+  return value;
+};
+
+export const getLettaAgentID = (): string => {
+  const value = Deno.env.get("LETTA_AGENT_ID")?.trim();
+
+  if (!value?.length) {
+    throw Error(
+      "Letta Agent ID not provided in `.env`. add variable `LETTA_AGENT_ID=`.",
+    );
+  } else if (!value.startsWith("agent-")) {
+    throw Error(
+      "Letta Agent ID is not formed correctly, check variable `LETTA_AGENT_ID`",
+    );
+  }
+
+  return value;
+};
+
+export const getLettaProjectName = (): string => {
+  const value = Deno.env.get("LETTA_PROJECT_NAME")?.trim();
+
+  if (!value?.length) {
+    throw Error(
+      "Letta Project Name not provided in `.env`. add variable `LETTA_PROJECT_NAME=`.",
+    );
+  }
+
+  return value;
+};
+
+// temporarily commenting out until switch to letta SDK 1.0
+// const getLettaProjectID = (): string => {
+//   const value = Deno.env.get("LETTA_PROJECT_ID")?.trim();
+
+//   if (!value?.length) {
+//     throw Error(
+//       "Letta Project ID not provided in `.env`. add variable `LETTA_PROJECT_ID=`.",
+//     );
+//   } else if (!value.includes("-")) {
+//     throw Error(
+//       "Letta Project ID is not formed correctly, check variable `LETTA_PROJECT_ID`",
+//     );
+//   }
+
+//   return value;
+// };
+
+const getAgentBskyHandle = (): string => {
+  const value = Deno.env.get("BSKY_USERNAME")?.trim();
+
+  if (!value?.length) {
+    throw Error(
+      "Bluesky Handle for agent not provided in `.env`. add variable `BSKY_USERNAME=`",
+    );
+  }
+
+  const cleanHandle = value.startsWith("@") ? value.slice(1) : value;
+
+  if (!cleanHandle.includes(".")) {
+    throw Error(
+      `Invalid handle format: ${value}. Expected format: user.bsky.social`,
+    );
+  }
+
+  return cleanHandle;
+};
+
+const getAgentBskyName = async (): Promise<string> => {
+  try {
+    const profile = await bsky.getProfile({ actor: getAgentBskyHandle() });
+    const displayName = profile?.data.displayName?.trim();
+
+    if (displayName) {
+      return displayName;
+    }
+    throw Error(`No display name found for ${getAgentBskyHandle()}`);
+  } catch (error) {
+    throw Error(`Failed to get display name: ${error}`);
+  }
+};
+
+const getResponsiblePartyName = (): string => {
+  const value = Deno.env.get("RESPONSIBLE_PARTY_NAME")?.trim();
+
+  if (!value?.length) {
+    throw Error("RESPONSIBLE_PARTY_NAME environment variable is not set");
+  }
+
+  return value;
+};
+
+const getResponsiblePartyContact = (): string => {
+  const value = Deno.env.get("RESPONSIBLE_PARTY_CONTACT")?.trim();
+
+  if (!value?.length) {
+    throw Error("RESPONSIBLE_PARTY_CONTACT environment variable is not set");
+  }
+
+  return value;
+};
+
+const getAutomationLevel = (): AutomationLevel => {
+  const value = Deno.env.get("AUTOMATION_LEVEL")?.trim();
+  const valid = validAutomationLevels;
+
+  if (!value) {
+    return "automated";
+  }
+
+  if (!valid.includes(value as typeof valid[number])) {
+    throw Error(
+      `Invalid automation level: ${value}. Must be one of: ${valid.join(", ")}`,
+    );
+  }
+
+  return value as AutomationLevel;
+};
+
+const setAgentBskyDID = (): string => {
+  if (!bsky.did) {
+    throw Error(`couldn't get DID for ${getAgentBskyHandle()}`);
+  } else {
+    return bsky.did;
+  }
+};
+
+const getBskyServiceUrl = (): string => {
+  const value = Deno.env.get("BSKY_SERVICE_URL")?.trim();
+
+  if (!value?.length || !value?.startsWith("https://")) {
+    return "https://bsky.social";
+  }
+
+  return value;
+};
+
+const getSupportedNotifTypes = (): notifType[] => {
+  const value = Deno.env.get("BSKY_NOTIFICATION_TYPES");
+
+  if (!value?.length) {
+    return ["mention", "reply"];
+  }
+
+  const notifList = value.split(",").map((type) => type.trim());
+
+  for (const notifType of notifList) {
+    if (
+      !validNotifTypes.includes(notifType as typeof validNotifTypes[number])
+    ) {
+      throw Error(
+        `"${notifType}" is not a valid notification type. check "BSKY_NOTIFICATION_TYPES" variable in your \`.env\` file.`,
+      );
+    }
+  }
+
+  return notifList as notifType[];
+};
+
+const getSupportedTools = (): allAgentTool[] => {
+  const value = Deno.env.get("BSKY_SUPPORTED_TOOLS");
+  const defaultTools: configAgentTool[] = [
+    "create_bluesky_post",
+    "update_bluesky_profile",
+  ];
+
+  if (!value?.length) {
+    return [...defaultTools, ...requiredAgentTools] as allAgentTool[];
+  }
+
+  const toolList = value.split(",").map((type) => type.trim());
+
+  for (const tool of toolList) {
+    if (!configAgentTools.includes(tool as typeof configAgentTools[number])) {
+      throw Error(
+        `"${tool}" is not a valid tool name. check "BSKY_SUPPORTED_TOOLS" variable in your \`.env\` file.`,
+      );
+    } else if (
+      requiredAgentTools.includes(tool as typeof requiredAgentTools[number])
+    ) {
+      throw Error(
+        `${tool} is always included and does not need to be added to "BSKY_SUPPORTED_TOOLS" in \`env\`.`,
+      );
+    }
+  }
+
+  return toolList.concat(requiredAgentTools) as allAgentTool[];
+};
+
+const getNotifDelayMinimum = (): number => {
+  const value = Number(Deno.env.get("NOTIF_DELAY_MINIMUM"));
+
+  if (isNaN(value) || value < msFrom.seconds(1) || value > msFrom.hours(24)) {
+    return msFrom.seconds(2);
+  }
+
+  return value;
+};
+
+const getNotifDelayMaximum = (): number => {
+  const value = Number(Deno.env.get("NOTIF_DELAY_MAXIMUM"));
+
+  if (isNaN(value) || value < msFrom.seconds(5) || value > msFrom.hours(24)) {
+    return msFrom.hours(1);
+  }
+
+  const minimum = getNotifDelayMinimum();
+
+  if (value <= minimum) {
+    throw Error(
+      `"NOTIF_DELAY_MAXIMUM" cannot be less than or equal to "NOTIF_DELAY_MINIMUM"`,
+    );
+  }
+
+  return value;
+};
+
+const getNotifDelayMultiplier = (): number => {
+  const value = Number(Deno.env.get("NOTIF_DELAY_MULTIPLIER"));
+
+  if (isNaN(value) || value < 0 || value > 500) {
+    return 1.05;
+  }
+
+  return (value / 100) + 1;
+};
+
+const getReflectionDelayMinimum = (): number => {
+  const value = Number(Deno.env.get("REFLECTION_DELAY_MINIMUM"));
+
+  if (isNaN(value) || value < msFrom.minutes(30) || value > msFrom.hours(24)) {
+    return msFrom.minutes(30);
+  }
+
+  return value;
+};
+
+const getReflectionDelayMaximum = (): number => {
+  const value = Number(Deno.env.get("REFLECTION_DELAY_MAXIMUM"));
+  const minimum = getReflectionDelayMinimum();
+
+  if (isNaN(value) || value < msFrom.minutes(60) || value > msFrom.hours(24)) {
+    return msFrom.hours(8);
+  }
+
+  if (value <= minimum) {
+    throw Error(
+      `"REFLECTION_DELAY_MAXIMUM" cannot be less than or equal to "REFLECTION_DELAY_MINIMUM"`,
+    );
+  }
+
+  return value;
+};
+
+const getProactiveDelayMinimum = (): number => {
+  const value = Number(Deno.env.get("PROACTIVE_DELAY_MINIMUM"));
+
+  if (isNaN(value) || value < msFrom.hours(1) || value > msFrom.hours(24)) {
+    return msFrom.hours(1);
+  }
+
+  return value;
+};
+
+const getProactiveDelayMaximum = (): number => {
+  const value = Number(Deno.env.get("PROACTIVE_DELAY_MAXIMUM"));
+  const minimum = getProactiveDelayMinimum();
+
+  if (isNaN(value) || value < msFrom.hours(3) || value > msFrom.hours(24)) {
+    return msFrom.hours(12);
+  }
+
+  if (value <= minimum) {
+    throw Error(
+      `"PROACTIVE_DELAY_MAXIMUM" cannot be less than or equal to "PROACTIVE_DELAY_MINIMUM"`,
+    );
+  }
+
+  return value;
+};
+
+const getWakeTime = (): number => {
+  const value = Math.round(Number(Deno.env.get("WAKE_TIME")));
+
+  if (!value) {
+    return 8;
+  }
+
+  if (value > 23) {
+    throw Error(`"WAKE_TIME" cannot be greater than 23 (11pm)`);
+  }
+
+  if (value < 0) {
+    throw Error(`"WAKE_TIME" cannot be less than 0 (midnight)`);
+  }
+
+  return value;
+};
+
+const getSleepTime = (): number => {
+  const value = Math.round(Number(Deno.env.get("SLEEP_TIME")));
+
+  if (!value) {
+    return 10;
+  }
+
+  if (value > 23) {
+    throw Error(`"SLEEP_TIME" cannot be greater than 23 (11pm)`);
+  }
+
+  if (value < 0) {
+    throw Error(`"SLEEP_TIME" cannot be less than 0 (midnight)`);
+  }
+
+  return value;
+};
+
+const getTimeZone = (): string => {
+  const value = Deno.env.get("TIMEZONE")?.trim();
+
+  if (!value?.length) {
+    return "America/Los_Angeles";
+  }
+
+  try {
+    Intl.DateTimeFormat(undefined, { timeZone: value });
+    return value;
+  } catch {
+    throw Error(
+      `Invalid timezone: ${value}. Must be a valid IANA timezone like "America/New_York"`,
+    );
+  }
+};
+
+const getResponsiblePartyType = (): ResponsiblePartyType => {
+  const value = Deno.env.get("RESPONSIBLE_PARTY_TYPE")?.trim().toLowerCase();
+
+  if (value === "person" || value === "organization") {
+    return value;
+  }
+
+  return "person";
+};
+
+const setReflectionEnabled = (): boolean => {
+  const reflectionMinVal = Deno.env.get("REFLECTION_DELAY_MINIMUM");
+  const reflectionMaxVal = Deno.env.get("REFLECTION_DELAY_MAXIMUM");
+
+  if (reflectionMinVal?.length && reflectionMaxVal?.length) {
+    return true;
+  }
+
+  return false;
+};
+
+const setProactiveEnabled = (): boolean => {
+  const proactiveMinVal = Deno.env.get("PROACTIVE_DELAY_MINIMUM");
+  const proactiveMaxVal = Deno.env.get("PROACTIVE_DELAY_MAXIMUM");
+
+  if (proactiveMinVal?.length && proactiveMaxVal?.length) {
+    return true;
+  }
+
+  return false;
+};
+
+const setSleepEnabled = (): boolean => {
+  const sleep = Deno.env.get("SLEEP_TIME");
+  const wake = Deno.env.get("WAKE_TIME");
+
+  if (sleep?.length && wake?.length) {
+    return true;
+  }
+
+  return false;
+};
+
+export const getBskyAppPassword = (): string => {
+  const value = Deno.env.get("BSKY_APP_PASSWORD")?.trim();
+
+  if (!value?.length) {
+    throw Error(
+      "Bluesky app password not provided in `.env`. add variable `BSKY_APP_PASSWORD=`",
+    );
+  }
+
+  const hyphenCount = value.split("-").length - 1;
+
+  if (value.length !== 19 || hyphenCount !== 2) {
+    throw Error(
+      "You are likely not using an app password. App passwords are 19 characters with 2 hyphens (format: xxxx-xxxx-xxxx). You can generate one at https://bsky.app/settings/app-passwords",
+    );
+  }
+
+  return value;
+};
+
+export const getAutomationDescription = (): string | undefined => {
+  const value = Deno.env.get("AUTOMATION_DESCRIPTION")?.trim();
+
+  if (!value?.length) {
+    return undefined;
+  }
+
+  if (value.length < 10) {
+    throw Error(
+      "Automation description must be at least 10 characters long",
+    );
+  }
+
+  return value;
+};
+
+export const getDisclosureUrl = (): string | undefined => {
+  const value = Deno.env.get("DISCLOSURE_URL")?.trim();
+
+  if (!value?.length) {
+    return undefined;
+  }
+
+  if (value.length < 6) {
+    throw Error(
+      "Disclosure URL must be at least 6 characters long",
+    );
+  }
+
+  return value;
+};
+
+export const getResponsiblePartyBsky = async (): Promise<
+  string | undefined
+> => {
+  const value = Deno.env.get("RESPONSIBLE_PARTY_BSKY")?.trim();
+
+  if (!value?.length) {
+    return undefined;
+  }
+
+  // If it's already a DID, return it
+  if (value.startsWith("did:")) {
+    return value;
+  }
+
+  // If it looks like a handle (contains a dot), resolve it to a DID
+  if (value.includes(".")) {
+    try {
+      const profile = await bsky.getProfile({ actor: value });
+      return profile.data.did;
+    } catch (error) {
+      throw Error(
+        `Failed to resolve DID for handle "${value}": ${error}`,
+      );
+    }
+  }
+
+  // Not a DID and not a handle
+  throw Error(
+    `Invalid RESPONSIBLE_PARTY_BSKY value: "${value}". Must be either a DID (starts with "did:") or a handle (contains ".")`,
+  );
+};
+
+const populateAgentContext = async (): Promise<agentContextObject> => {
+  console.log("building new agentContext object…");
+  const context: agentContextObject = {
+    // state
+    busy: false,
+    sleeping: false,
+    checkCount: 0,
+    reflectionCount: 0,
+    processingCount: 0,
+    proactiveCount: 0,
+    likeCount: 0,
+    repostCount: 0,
+    followCount: 0,
+    mentionCount: 0,
+    replyCount: 0,
+    quoteCount: 0,
+    // required with manual variables
+    lettaProjectIdentifier: getLettaProjectName(),
+    agentBskyHandle: getAgentBskyHandle(),
+    agentBskyName: await getAgentBskyName(),
+    agentBskyDID: setAgentBskyDID(),
+    responsiblePartyName: getResponsiblePartyName(),
+    responsiblePartyContact: getResponsiblePartyContact(),
+    agentBskyServiceUrl: getBskyServiceUrl(),
+    automationLevel: getAutomationLevel(),
+    supportedNotifTypes: getSupportedNotifTypes(),
+    supportedTools: getSupportedTools(),
+    notifDelayMinimum: getNotifDelayMinimum(),
+    notifDelayMaximum: getNotifDelayMaximum(),
+    notifDelayMultiplier: getNotifDelayMultiplier(),
+    reflectionDelayMinimum: getReflectionDelayMinimum(),
+    reflectionDelayMaximum: getReflectionDelayMaximum(),
+    proactiveDelayMinimum: getProactiveDelayMinimum(),
+    proactiveDelayMaximum: getProactiveDelayMaximum(),
+    wakeTime: getWakeTime(),
+    sleepTime: getSleepTime(),
+    timeZone: getTimeZone(),
+    responsiblePartyType: getResponsiblePartyType(),
+    reflectionEnabled: setReflectionEnabled(),
+    proactiveEnabled: setProactiveEnabled(),
+    sleepEnabled: setSleepEnabled(),
+    notifDelayCurrent: getNotifDelayMinimum(),
+    reflectionDelayCurrent: getReflectionDelayMinimum(),
+    proactiveDelayCurrent: getProactiveDelayMinimum(),
+  };
+
+  const automationDescription = getAutomationDescription();
+  if (automationDescription) {
+    context.automationDescription = automationDescription;
+  }
+
+  const disclosureUrl = getDisclosureUrl();
+  if (disclosureUrl) {
+    context.disclosureUrl = disclosureUrl;
+  }
+
+  const responsiblePartyBsky = await getResponsiblePartyBsky();
+  if (responsiblePartyBsky) {
+    context.responsiblePartyBsky = responsiblePartyBsky;
+  }
+  console.log(
+    `\`agentContext\` object built for ${context.agentBskyName}, BEGIN TASK…`,
+  );
+  return context;
+};
+
+export const agentContext = await populateAgentContext();
+
+export const claimTaskThread = () => {
+  if (agentContext.busy) return false;
+  agentContext.busy = true;
+  return true;
+};
+
+export const releaseTaskThread = () => {
+  agentContext.busy = false;
+};
+
+export const resetSessionCounts = () => {
+  agentContext.likeCount = 0;
+  agentContext.repostCount = 0;
+  agentContext.followCount = 0;
+  agentContext.mentionCount = 0;
+  agentContext.replyCount = 0;
+  agentContext.quoteCount = 0;
+  agentContext.checkCount = 0;
+  agentContext.processingCount = 0;
+};

utils/const.ts

···
+export const validAutomationLevels = [
+  "assisted",
+  "collaborative",
+  "automated",
+] as const;
+
+export const validNotifTypes = [
+  "like",
+  "repost",
+  "follow",
+  "mention",
+  "reply",
+  "quote",
+] as const;
+
+export const configAgentTools = [
+  "create_bluesky_post",
+  "like_bluesky_post",
+  "quote_bluesky_post",
+  "repost_bluesky_post",
+  "update_bluesky_connection",
+  "update_bluesky_profile",
+] as const;
+
+export const requiredAgentTools = [
+  "fetch_bluesky_posts",
+  "get_bluesky_user_info",
+  "ignore_notification",
+  "mute_bluesky_thread",
+  "search_bluesky",
+] as const;
+
+export const allAgentTools = [
+  ...configAgentTools,
+  ...requiredAgentTools,
+] as const;

utils/declaration.ts

···
 import { bsky } from "../utils/bsky.ts";
+import type { AutonomyDeclarationRecord } from "./types.ts";
 import { Lexicons } from "@atproto/lexicon";
 
-// schema for updating PDS to indicate account is AI
-export const AI_DECLARATION_LEXICON = {
+export const AUTONOMY_DECLARATION_LEXICON = {
   "lexicon": 1,
-  "id": "studio.voyager.account.managedByAI",
+  "id": "studio.voyager.account.autonomy",
   "defs": {
     "main": {
       "type": "record",
···
       "record": {
         "type": "object",
         "properties": {
-          "aiRole": {
+          "automationLevel": {
             "type": "string",
-            "enum": [
-              "autonomous",
-              "collaborative",
+            "knownValues": [
+              "human",
               "assisted",
+              "collaborative",
+              "automated",
             ],
-            "description": "Level of AI involvement in account management",
+            "description":
+              "Level of automation in account management and content creation",
           },
-          "createdAt": {
-            "type": "string",
-            "format": "datetime",
-            "description": "timestamp when this declaration was created",
+          "usesGenerativeAI": {
+            "type": "boolean",
+            "description":
+              "Whether this account uses generative AI (LLMs, image generation, etc.) to create content",
           },
           "description": {
             "type": "string",
-            "maxLength": 500,
+            "maxGraphemes": 300,
             "description":
-              "additional context about this AI account's purpose or operation",
+              "Plain language explanation of how this account is automated and what it does",
           },
           "responsibleParty": {
             "type": "object",
             "properties": {
-              "did": {
+              "type": {
                 "type": "string",
-                "format": "did",
-                "description": "DID of the responsible party",
+                "knownValues": [
+                  "person",
+                  "organization",
+                ],
+                "description":
+                  "Whether the responsible party is a person or organization",
               },
               "name": {
                 "type": "string",
-                "maxLength": 100,
-                "description": "name of the person or organization responsible",
+                "maxGraphemes": 100,
+                "description": "Name of the person or organization responsible",
               },
               "contact": {
                 "type": "string",
                 "maxLength": 300,
-                "description": "contact info (email, url, etc)",
+                "description":
+                  "Contact information (email, URL, handle, or DID)",
+              },
+              "did": {
+                "type": "string",
+                "format": "did",
+                "description":
+                  "DID of the responsible party if they have an ATProto identity",
               },
             },
             "description":
-              "info about the person or organization that is responsible for creating/managing this account",
+              "Information about who is accountable for this account's automated behavior",
+          },
+          "disclosureUrl": {
+            "type": "string",
+            "format": "uri",
+            "description":
+              "URL with additional information about this account's automation",
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "datetime",
+            "description": "Timestamp when this declaration was created",
           },
         },
         "required": [
-          "aiRole",
           "createdAt",
         ],
       },
-      "description": "declaration that this account is managed by AI",
+      "description":
+        "Declaration of automation and AI usage for transparency and accountability",
     },
   },
 };
 
-export type AIDeclarationRecord = {
-  $type: "studio.voyager.account.managedByAI";
-  aiRole: "autonomous" | "collaborative" | "assisted";
-  createdAt: string; // ISO datetime
-  description?: string;
-  responsibleParty?: {
-    did?: string;
-    name?: string;
-    contact?: string;
-  };
-};
-
-export const createDeclarationRecord = async () => {
-  const role = Deno.env.get("AI_ROLE")?.toLowerCase();
+export const createAutonomyDeclarationRecord = async () => {
+  const automationLevel = Deno.env.get("AUTOMATION_LEVEL")?.toLowerCase();
   const projectDescription = Deno.env.get("PROJECT_DESCRIPTION");
-  const authorHandle = Deno.env.get("AUTHOR_BSKY_HANDLE");
-  const authorName = Deno.env.get("AUTHOR_NAME");
-  const authorContact = Deno.env.get("AUTHOR_CONTACT");
+  const disclosureUrl = Deno.env.get("DISCLOSURE_URL");
 
-  const declarationRecord: AIDeclarationRecord = {
-    $type: "studio.voyager.account.managedByAI",
-    aiRole:
-      (role === "autonomous" || role === "collaborative" || role === "assisted")
-        ? role
-        : "autonomous",
+  const responsiblePartyType = Deno.env.get("RESPONSIBLE_PARTY_TYPE")
+    ?.toLowerCase();
+  const responsiblePartyName = Deno.env.get("RESPONSIBLE_PARTY_NAME");
+  const responsiblePartyContact = Deno.env.get("RESPONSIBLE_PARTY_CONTACT");
+  const responsiblePartyBsky = Deno.env.get("RESPONSIBLE_PARTY_BSKY");
+
+  const declarationRecord: AutonomyDeclarationRecord = {
+    $type: "studio.voyager.account.autonomy",
+    usesGenerativeAI: true, // Always true for this project
+    automationLevel: (automationLevel === "assisted" ||
+        automationLevel === "collaborative" ||
+        automationLevel === "automated")
+      ? automationLevel
+      : "automated", // Default to automated if not specified or invalid
     createdAt: new Date().toISOString(),
   };
 
+  // Add description if provided
   if (projectDescription?.trim()) {
-    declarationRecord.description = projectDescription;
+    declarationRecord.description = projectDescription.trim();
+  }
+
+  // Add disclosure URL if provided
+  if (disclosureUrl?.trim()) {
+    declarationRecord.disclosureUrl = disclosureUrl.trim();
   }
 
-  if (authorHandle || authorName || authorContact) {
+  // Build responsible party object if any fields are provided
+  if (
+    responsiblePartyType ||
+    responsiblePartyName ||
+    responsiblePartyContact ||
+    responsiblePartyBsky
+  ) {
     declarationRecord.responsibleParty = {};
 
-    if (authorHandle) {
-      const authorData = await bsky.getProfile({ actor: authorHandle });
-      declarationRecord.responsibleParty.did = authorData.data.did;
+    // Add type if provided and valid
+    if (
+      responsiblePartyType === "person" ||
+      responsiblePartyType === "organization"
+    ) {
+      declarationRecord.responsibleParty.type = responsiblePartyType;
     }
 
-    if (authorName) {
-      declarationRecord.responsibleParty.name = authorName;
+    // Add name if provided
+    if (responsiblePartyName?.trim()) {
+      declarationRecord.responsibleParty.name = responsiblePartyName.trim();
     }
 
-    if (authorContact) {
-      declarationRecord.responsibleParty.contact = authorContact;
+    // Add contact if provided
+    if (responsiblePartyContact?.trim()) {
+      declarationRecord.responsibleParty.contact = responsiblePartyContact
+        .trim();
+    }
+
+    // Handle DID or Handle from RESPONSIBLE_PARTY_BSKY
+    if (responsiblePartyBsky?.trim()) {
+      const bskyIdentifier = responsiblePartyBsky.trim();
+
+      // Check if it's a DID (starts with "did:")
+      if (bskyIdentifier.startsWith("did:")) {
+        declarationRecord.responsibleParty.did = bskyIdentifier;
+      } else {
+        // Assume it's a handle and resolve to DID
+        try {
+          const authorData = await bsky.getProfile({ actor: bskyIdentifier });
+          declarationRecord.responsibleParty.did = authorData.data.did;
+        } catch (error) {
+          console.warn(
+            `Failed to resolve DID for identifier ${bskyIdentifier}:`,
+            error,
+          );
+          // Continue without DID rather than failing
+        }
+      }
     }
   }
 
   return declarationRecord;
 };
 
-export const submitDeclarationRecord = async () => {
+export const submitAutonomyDeclarationRecord = async () => {
   const lex = new Lexicons();
 
   try {
-    lex.add(AI_DECLARATION_LEXICON as any);
-    const record = await createDeclarationRecord();
+    lex.add(AUTONOMY_DECLARATION_LEXICON as any);
+    const record = await createAutonomyDeclarationRecord();
 
     lex.assertValidRecord(
-      "studio.voyager.account.managedByAI",
+      "studio.voyager.account.autonomy",
       record,
     );
 
···
     try {
       await bsky.com.atproto.repo.getRecord({
         repo,
-        collection: "studio.voyager.account.managedByAI",
+        collection: "studio.voyager.account.autonomy",
         rkey: "self",
       });
       exists = true;
-      console.log("Existing declaration record found - updating...");
+      console.log("Existing autonomy declaration found - updating...");
     } catch (error: any) {
       // Handle "record not found" errors (status 400 with error: "RecordNotFound")
       const isNotFound =
···
         error?.message?.includes("Could not locate record");
 
       if (isNotFound) {
-        console.log("No existing declaration record found - creating new...");
+        console.log("No existing autonomy declaration found - creating new...");
       } else {
         // Re-throw if it's not a "not found" error
         throw error;
···
     // Create or update the record
     const result = await bsky.com.atproto.repo.putRecord({
       repo,
-      collection: "studio.voyager.account.managedByAI",
+      collection: "studio.voyager.account.autonomy",
       rkey: "self",
       record,
     });
 
     console.log(
-      `Declaration record ${exists ? "updated" : "created"} successfully:`,
+      `Autonomy declaration ${exists ? "updated" : "created"} successfully:`,
       result,
     );
     return result;
   } catch (error) {
-    console.error("error submitting declaration record", error);
+    console.error("Error submitting autonomy declaration record:", error);
     throw error;
   }
 };

utils/messageAgent.ts

···
 import { LettaClient } from "@letta-ai/letta-client";
-import { session } from "./session.ts";
-
+import { agentContext } from "./agentContext.ts";
 // Helper function to format tool arguments as inline key-value pairs
 const formatArgsInline = (args: unknown): string => {
   try {
···
       if (response.messageType === "reasoning_message") {
         console.log(`💭 reasoning…`);
       } else if (response.messageType === "assistant_message") {
-        console.log(`💬 ${session.agentName}: ${response.content}`);
+        console.log(`💬 ${agentContext.agentBskyName}: ${response.content}`);
       } else if (response.messageType === "tool_call_message") {
         const formattedArgs = formatArgsInline(response.toolCall.arguments);
         console.log(

utils/processNotification.ts

···
 import type { Notification } from "./types.ts";
-import { session } from "./session.ts";
+import { agentContext } from "./agentContext.ts";
 import { messageAgent } from "./messageAgent.ts";
 
 import { likePrompt } from "../prompts/likePrompt.ts";
···
       error,
     );
   } finally {
-    (session as any)[handler]++;
+    (agentContext as any)[handler]++;
   }
 };

utils/time.ts

···
-import { session } from "./session.ts";
+import { agentContext } from "./agentContext.ts";
 import { Temporal } from "@js-temporal/polyfill";
 
 /**
+ * Convert time units to milliseconds
+ */
+export const msFrom = {
+  /**
+   * Convert seconds to milliseconds
+   * @param s - number of seconds
+   */
+  seconds: (seconds: number): number => seconds * 1000,
+  /**
+   * Convert minutes to milliseconds
+   * @param m - number of minutes
+   */
+  minutes: (minutes: number): number => minutes * 60 * 1000,
+  /**
+   * Convert hours to milliseconds
+   * @param h - number of hours
+   */
+  hours: (hours: number): number => hours * 60 * 60 * 1000,
+};
+
+/**
  * Generate a random time interval in milliseconds within a defined range
  *
- * @param minMinutes - the minimum duration in minutes (default: 5)
- * @param maxMinutes - the maximum duration in minutes (default: 15)
+ * @param minimum - the minimum duration in milliseconds (default: 5 minutes)
+ * @param maximum - the maximum duration in milliseconds (default: 15 minutes)
  * @returns A random time interval in milliseconds between the min and max range
- * @throws {Error} if Max <= min, if either value is negative, or if either is > 12 hours
  */
 
 export const msRandomOffset = (
-  minMinutes: number = 5,
-  maxMinutes: number = 15,
+  minimum: number = msFrom.minutes(5),
+  maximum: number = msFrom.minutes(15),
 ): number => {
-  const maximumOutputMinutes = 1440; // 24 hours
-  if (maxMinutes <= minMinutes) {
-    throw new Error("Maximum minutes must be larger than minimum minutes");
+  if (maximum <= minimum) {
+    throw new Error("Maximum time must be larger than minimum time");
   }
 
-  if (minMinutes < 0 || maxMinutes < 0) {
+  if (minimum < 0 || maximum < 0) {
     throw new Error("Time values must be non-negative");
   }
 
-  if (Math.max(minMinutes, maxMinutes) > maximumOutputMinutes) {
-    console.log("max minutes: ", maxMinutes, "min minutes :", minMinutes);
+  if (Math.max(minimum, maximum) > msFrom.hours(24)) {
     throw new Error(
-      `time values must not exceed ${maximumOutputMinutes} (${
-        maximumOutputMinutes / 60
-      } hours)`,
+      `time values must not exceed ${
+        msFrom.hours(24)
+      } (24 hours). you entered: [min: ${minimum}ms, max: ${maximum}ms]`,
     );
   }
 
-  const min = Math.ceil((minMinutes * 60) * 1000);
-  const max = Math.floor((maxMinutes * 60) * 1000);
+  const min = Math.ceil(minimum);
+  const max = Math.floor(maximum);
 
   return Math.floor(Math.random() * (max - min) + min);
 };
 
+/**
+ * finds the time in milliseconds until the next wake window
+ *
+ * @param minimumOffset - the minimum duration in milliseconds to offset from the window
+ * @param maximumOffset - the maximum duration in milliseconds to offset from the window
+ * @returns time until next wake window plus random offset, in milliseconds
+ */
 export const msUntilNextWakeWindow = (
-  sleepTime: number,
-  wakeTime: number,
-  minMinutesOffset: number,
-  maxMinutesOffset: number,
+  minimumOffset: number,
+  maximumOffset: number,
 ): number => {
-  const current = Temporal.Now.zonedDateTimeISO(session.timeZone);
+  const current = Temporal.Now.zonedDateTimeISO(agentContext.timeZone);
+
+  if (!agentContext.sleepEnabled) {
+    return 0;
+  }
 
-  if (current.hour >= wakeTime && current.hour < sleepTime) {
+  if (
+    current.hour >= agentContext.wakeTime &&
+    current.hour < agentContext.sleepTime
+  ) {
     return 0;
   } else {
     let newTime;
 
-    if (current.hour < wakeTime) {
-      newTime = current.with({ hour: wakeTime });
+    if (current.hour < agentContext.wakeTime) {
+      newTime = current.with({ hour: agentContext.wakeTime });
     } else {
-      newTime = current.add({ days: 1 }).with({ hour: wakeTime });
+      newTime = current.add({ days: 1 }).with({ hour: agentContext.wakeTime });
     }
 
     return newTime.toInstant().epochMilliseconds +
-      msRandomOffset(minMinutesOffset, maxMinutesOffset) -
+      msRandomOffset(minimumOffset, maximumOffset) -
       current.toInstant().epochMilliseconds;
   }
 };
 
+/**
+ * Calculate the time until next configurable window, plus a random offset.
+ * @param window - the hour of the day to wake up at
+ * @param minimumOffset - the minimum duration in milliseconds to offset from the window
+ * @param maximumOffset - the maximum duration in milliseconds to offset from the window
+ * @returns time until next daily window plus random offset, in milliseconds
+ */
 export const msUntilDailyWindow = (
   window: number,
-  minMinutesOffset: number,
-  maxMinutesOffset: number,
-) => {
-  const current = Temporal.Now.zonedDateTimeISO(session.timeZone);
+  minimumOffset: number,
+  maximumOffset: number,
+): number => {
+  const current = Temporal.Now.zonedDateTimeISO(agentContext.timeZone);
+
+  if (window > 23) {
+    throw Error("window hour cannot exceed 23 (11pm)");
+  }
 
   let msToWindow;
   if (current.hour < window) {
···
   }
 
   return msToWindow +
-    msRandomOffset(minMinutesOffset, maxMinutesOffset) -
+    msRandomOffset(minimumOffset, maximumOffset) -
     current.toInstant().epochMilliseconds;
 };
 
 export const getNow = () => {
-  return Temporal.Now.zonedDateTimeISO(session.timeZone);
+  return Temporal.Now.zonedDateTimeISO(agentContext.timeZone);
 };

utils/types.ts

···
 import type { AppBskyNotificationListNotifications } from "@atproto/api";
+import {
+  allAgentTools,
+  configAgentTools,
+  requiredAgentTools,
+  validAutomationLevels,
+  validNotifTypes,
+} from "./const.ts";
+export type Notification = AppBskyNotificationListNotifications.Notification;
 
-export type Notification = AppBskyNotificationListNotifications.Notification;
+export type AutomationLevel = typeof validAutomationLevels[number];
+export type ResponsiblePartyType = "person" | "organization";
+
+export type notifType = typeof validNotifTypes[number];
+
+export type configAgentTool = typeof configAgentTools[number];
+export type requiredAgentTool = typeof requiredAgentTools[number];
+export type allAgentTool = typeof allAgentTools[number];
+
+export type agentContextObject = {
+  // state
+  busy: boolean;
+  sleeping: boolean;
+  checkCount: number;
+  reflectionCount: number;
+  processingCount: number;
+  proactiveCount: number;
+  likeCount: number;
+  repostCount: number;
+  followCount: number;
+  mentionCount: number;
+  replyCount: number;
+  quoteCount: number;
+  // required manual variables
+  lettaProjectIdentifier: string;
+  agentBskyHandle: string;
+  agentBskyName: string;
+  responsiblePartyName: string; // what person or org is responsible for this bot?
+  responsiblePartyContact: string; // email or url for people to contact about bot
+  // required variables with fallbacks
+  agentBskyServiceUrl: string;
+  automationLevel: AutomationLevel;
+  supportedNotifTypes: notifType[];
+  supportedTools: allAgentTool[];
+  notifDelayMinimum: number;
+  notifDelayMaximum: number;
+  notifDelayMultiplier: number;
+  reflectionDelayMinimum: number;
+  reflectionDelayMaximum: number;
+  proactiveDelayMinimum: number;
+  proactiveDelayMaximum: number;
+  wakeTime: number;
+  sleepTime: number;
+  timeZone: string;
+  responsiblePartyType: string; // person / organization
+  // set automatically
+  agentBskyDID: string;
+  reflectionEnabled: boolean;
+  proactiveEnabled: boolean;
+  sleepEnabled: boolean;
+  notifDelayCurrent: number;
+  reflectionDelayCurrent: number;
+  proactiveDelayCurrent: number;
+  // optional
+  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
+};
+
+export type AutonomyDeclarationRecord = {
+  $type: "studio.voyager.account.autonomy";
+
+  // How automated is this account?
+  automationLevel?: "human" | "assisted" | "collaborative" | "automated";
+
+  // Is AI involved in content creation?
+  usesGenerativeAI?: boolean;
+
+  // Plain language explanation
+  description?: string; // maxGraphemes: 300
+
+  // Who is accountable for this account?
+  responsibleParty?: {
+    type?: "person" | "organization";
+    name?: string;
+    contact?: string; // email, URL, handle, or DID
+    did?: string; // ATProto DID
+  };
+
+  // Where can someone learn more?
+  disclosureUrl?: string; // URI format
+
+  // When was this declaration created?
+  createdAt: string; // ISO datetime (required)
+};
 
 export type memoryBlock = {
   label: string;