ei-tui 0.8.1 → 0.9.0

package/tui/src/commands/reflect.tsx

@@ -0,0 +1,375 @@
+import { useKeyboard } from "@opentui/solid";
+import { onMount, onCleanup } from "solid-js";
+import * as fs from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import type { Command, CommandContext } from "./registry";
+import type { PersonaEntity } from "../../../src/core/types.js";
+import { ConfirmOverlay } from "../components/ConfirmOverlay.js";
+import {
+  personaPreviewToYAML,
+  personaPreviewFromYAML,
+} from "../util/yaml-serializers.js";
+import { useKeyboardNav } from "../context/keyboard.js";
+
+function wrapComment(text: string, width = 78): string {
+  const words = text.split(/\s+/);
+  const lines: string[] = [];
+  let current = "";
+  for (const word of words) {
+    if (current && (current + " " + word).length > width) {
+      lines.push(`# ${current}`);
+      current = word;
+    } else {
+      current = current ? `${current} ${word}` : word;
+    }
+  }
+  if (current) lines.push(`# ${current}`);
+  return lines.join("\n");
+}
+
+function getDataPath(): string {
+  const raw = process.env.EI_DATA_PATH ??
+    join(process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share"), "ei");
+  return raw.replace(/\/+$/, "");
+}
+
+function getReflectFolder(persona: PersonaEntity): string {
+  const datePrefix = persona.pending_update!.created_at.slice(0, 10);
+  const safeName = persona.display_name.replace(/\s+/g, "_");
+  return join(getDataPath(), "reflect", `${datePrefix}_${safeName}`);
+}
+
+async function resolveReflectionPersona(
+  args: string[],
+  ctx: CommandContext
+): Promise<{ personaId: string; persona: PersonaEntity } | null> {
+  const SUBCOMMANDS = new Set(["generate", "update", "apply", "dismiss"]);
+  const nameArgs = SUBCOMMANDS.has(args[0]?.toLowerCase() ?? "") ? args.slice(1) : args;
+  const name = nameArgs.join(" ").trim();
+
+  let personaId: string | null;
+  if (name) {
+    personaId = await ctx.ei.resolvePersonaName(name);
+    if (!personaId) {
+      ctx.showNotification(`No persona named "${name}"`, "error");
+      return null;
+    }
+  } else {
+    personaId = ctx.ei.activePersonaId();
+    if (!personaId) {
+      ctx.showNotification("No active persona", "error");
+      return null;
+    }
+  }
+
+  const persona = await ctx.ei.getPersona(personaId);
+  if (!persona) {
+    ctx.showNotification("Could not load persona", "error");
+    return null;
+  }
+
+  if (!persona.pending_update) {
+    ctx.showNotification(`No pending reflection for ${persona.display_name}`, "error");
+    return null;
+  }
+
+  return { personaId, persona };
+}
+
+export const reflectCommand: Command = {
+  name: "reflect",
+  aliases: ["rf"],
+  description:
+    "Review a persona's pending reflection — compare current vs proposed identity while chatting",
+  usage: "/reflect [generate|update|apply|dismiss]",
+
+  async execute(args, ctx) {
+    const subcommand = args[0]?.toLowerCase();
+
+    if (!subcommand || !["generate", "update", "apply", "dismiss"].includes(subcommand)) {
+      const activeId = ctx.ei.activePersonaId();
+      const activePersona = activeId ? ctx.ei.personas().find(p => p.id === activeId) : null;
+      const hasPending = activePersona?.has_pending_update ?? false;
+      const pendingPersonas = hasPending
+        ? []
+        : ctx.ei.personas().filter(p => p.has_pending_update);
+
+      if (!hasPending && pendingPersonas.length === 0) {
+        ctx.showNotification("No pending reflections.", "info");
+        return;
+      }
+
+      const headerName = hasPending ? activePersona!.display_name : undefined;
+      const pendingNames = pendingPersonas.map(p => p.display_name);
+      const dataPath = getDataPath();
+
+      ctx.showOverlay((hideOverlay, _hideForEditor) => {
+        const { setOverlayActive } = useKeyboardNav();
+        onMount(() => setOverlayActive(true));
+        onCleanup(() => setOverlayActive(false));
+        useKeyboard((event) => {
+          event.preventDefault();
+          hideOverlay();
+        });
+
+        const header = headerName
+          ? `✦ Persona Reflection: ${headerName}`
+          : `✦ Persona Reflection — pending: ${pendingNames.join(", ")}`;
+
+        return (
+          <box
+            position="absolute"
+            width="100%"
+            height="100%"
+            left={0}
+            top={0}
+            backgroundColor="#000000"
+            alignItems="center"
+            justifyContent="center"
+          >
+            <box
+              width={64}
+              backgroundColor="#1a1a2e"
+              borderStyle="single"
+              borderColor="#586e75"
+              padding={2}
+              flexDirection="column"
+            >
+              <text fg="#eee8d5">{header}</text>
+              <text> </text>
+              <text fg="#839496">{"Personas grow through conversation. Reflection is a chance"}</text>
+              <text fg="#839496">{"to review proposed changes to their Identity with them."}</text>
+              <text fg="#839496">{"Open the generated files in your editor while you chat."}</text>
+              <text> </text>
+              <text fg="#268bd2">{"  /reflect generate   Write current + proposed YAML files"}</text>
+              <text fg="#268bd2">{"  /reflect update     Read proposed.yaml back into Ei"}</text>
+              <text fg="#268bd2">{"                      (Persona sees updated data)"}</text>
+              <text fg="#268bd2">{"  /reflect apply      Write proposed.yaml to your Persona"}</text>
+              <text fg="#268bd2">{"  /reflect dismiss    Discard without changing anything"}</text>
+              <text> </text>
+              <text fg="#839496">{dataPath.replace(homedir(), "~") + "/reflect/YYYY-MM-DD_Name/"}</text>
+              <text fg="#839496">{"  ├── current.yaml   # Read-Only Reference"}</text>
+              <text fg="#839496">{"  └── proposed.yaml  # Edit while Chatting"}</text>
+              <text> </text>
+              <text fg="#586e75">{"[Press any key to close]"}</text>
+            </box>
+          </box>
+        );
+      }, ctx.renderer);
+      return;
+    }
+
+    if (subcommand === "generate") {
+      const result = await resolveReflectionPersona(args, ctx);
+      if (!result) return;
+      const { persona } = result;
+
+      const folderPath = getReflectFolder(persona);
+
+      if (fs.existsSync(folderPath)) {
+        const date = persona.pending_update!.created_at.slice(0, 10);
+        ctx.showNotification(`Found existing reflection from ${date}, regenerating...`, "info");
+        fs.rmSync(folderPath, { recursive: true, force: true });
+      }
+      fs.mkdirSync(folderPath, { recursive: true });
+
+      const now = new Date().toISOString();
+      const critique = wrapComment(persona.pending_update!.critique);
+
+      const currentHeader = [
+        `# Current Identity: ${persona.display_name}`,
+        `# This is the CURRENT identity — for reference only. Do not edit this file.`,
+        `# Generated: ${now}`,
+        `#`,
+        `# Critique from reflection analysis:`,
+        critique,
+        ``,
+      ].join("\n");
+
+      const currentYAML = personaPreviewToYAML(
+        {
+          long_description: persona.long_description ?? "",
+          short_description: persona.short_description ?? "",
+          traits: (persona.traits ?? []).map(t => ({
+            name: t.name,
+            description: t.description,
+            strength: t.strength ?? 0.5,
+            sentiment: t.sentiment ?? 0,
+          })),
+          topics: (persona.topics ?? []).map(t => ({
+            name: t.name,
+            perspective: t.perspective,
+            approach: t.approach,
+            personal_stake: t.personal_stake,
+            sentiment: t.sentiment ?? 0,
+            exposure_current: t.exposure_current ?? 0.5,
+            exposure_desired: t.exposure_desired ?? 0.5,
+          })),
+        },
+        persona.display_name
+      );
+
+      fs.writeFileSync(join(folderPath, "current.yaml"), currentHeader + currentYAML, "utf-8");
+
+      const proposedHeader = [
+        `# Proposed Identity: ${persona.display_name}`,
+        `# Edit this file freely. Use /reflect update to sync changes into the system.`,
+        `# Use /reflect apply when done, or /reflect dismiss to discard.`,
+        ``,
+      ].join("\n");
+
+      const proposedYAML = personaPreviewToYAML(
+        {
+          long_description: persona.pending_update!.long_description,
+          short_description: persona.pending_update!.short_description ?? "",
+          traits: (persona.pending_update!.traits ?? []).map(t => ({
+            name: t.name,
+            description: t.description,
+            strength: t.strength ?? 0.5,
+            sentiment: t.sentiment ?? 0,
+          })),
+          topics: (persona.pending_update!.topics ?? []).map(t => ({
+            name: t.name,
+            perspective: t.perspective,
+            approach: t.approach,
+            personal_stake: t.personal_stake,
+            sentiment: t.sentiment ?? 0,
+            exposure_current: t.exposure_current ?? 0.5,
+            exposure_desired: t.exposure_desired ?? 0.5,
+          })),
+        },
+        persona.display_name
+      );
+
+      fs.writeFileSync(join(folderPath, "proposed.yaml"), proposedHeader + proposedYAML, "utf-8");
+
+      ctx.showNotification(
+        `Reflection files written to ${folderPath} — open proposed.yaml in your editor alongside this chat`,
+        "info"
+      );
+      return;
+    }
+
+    if (subcommand === "update") {
+      const result = await resolveReflectionPersona(args, ctx);
+      if (!result) return;
+      const { personaId, persona } = result;
+
+      const folderPath = getReflectFolder(persona);
+      if (!fs.existsSync(folderPath)) {
+        ctx.showNotification(
+          `No reflection folder found — run /reflect generate first`,
+          "error"
+        );
+        return;
+      }
+
+      const proposedContent = fs.readFileSync(join(folderPath, "proposed.yaml"), "utf-8");
+
+      let parsed: ReturnType<typeof personaPreviewFromYAML>;
+      try {
+        parsed = personaPreviewFromYAML(proposedContent);
+      } catch (e) {
+        ctx.showNotification(
+          `Parse error: ${e instanceof Error ? e.message : String(e)}`,
+          "error"
+        );
+        return;
+      }
+
+      await ctx.ei.updatePersona(personaId, {
+        pending_update: {
+          critique: persona.pending_update!.critique,
+          created_at: persona.pending_update!.created_at,
+          long_description: parsed.long_description,
+          short_description: parsed.short_description ?? persona.pending_update!.short_description,
+          traits: parsed.traits,
+          topics: parsed.topics,
+        },
+      });
+
+      ctx.showNotification(
+        `Updated — ${persona.display_name} will see your changes in the next message`,
+        "info"
+      );
+      return;
+    }
+
+    if (subcommand === "apply") {
+      const result = await resolveReflectionPersona(args, ctx);
+      if (!result) return;
+      const { personaId, persona } = result;
+
+      const folderPath = getReflectFolder(persona);
+
+      let finalParsed: ReturnType<typeof personaPreviewFromYAML> | null = null;
+      if (fs.existsSync(folderPath)) {
+        const proposedPath = join(folderPath, "proposed.yaml");
+        if (fs.existsSync(proposedPath)) {
+          const proposedContent = fs.readFileSync(proposedPath, "utf-8");
+          try {
+            finalParsed = personaPreviewFromYAML(proposedContent);
+          } catch (e) {
+            ctx.showNotification(
+              `Parse error in proposed.yaml: ${e instanceof Error ? e.message : String(e)}`,
+              "error"
+            );
+            return;
+          }
+        }
+      }
+
+      const source = finalParsed ?? {
+        long_description: persona.pending_update!.long_description,
+        short_description: persona.pending_update!.short_description as string | undefined,
+        traits: persona.pending_update!.traits,
+        topics: persona.pending_update!.topics,
+      };
+
+      await ctx.ei.updatePersona(personaId, {
+        long_description: source.long_description,
+        short_description: source.short_description,
+        traits: source.traits,
+        topics: source.topics,
+        pending_update: undefined,
+      });
+
+      if (fs.existsSync(folderPath)) {
+        fs.rmSync(folderPath, { recursive: true, force: true });
+      }
+
+      ctx.showNotification(`Applied reflection for ${persona.display_name}`, "info");
+      return;
+    }
+
+    if (subcommand === "dismiss") {
+      const result = await resolveReflectionPersona(args, ctx);
+      if (!result) return;
+      const { personaId, persona } = result;
+
+      const confirmed = await new Promise<boolean>((resolve) => {
+        ctx.showOverlay((hideOverlay, _hideForEditor) => (
+          <ConfirmOverlay
+            message={`Discard this reflection for ${persona.display_name}? The proposed identity will be lost.`}
+            onConfirm={() => { hideOverlay(); resolve(true); }}
+            onCancel={() => { hideOverlay(); resolve(false); }}
+          />
+        ), ctx.renderer);
+      });
+
+      if (!confirmed) {
+        ctx.showNotification("Cancelled", "info");
+        return;
+      }
+
+      await ctx.ei.updatePersona(personaId, { pending_update: undefined });
+      const folderPath = getReflectFolder(persona);
+      if (fs.existsSync(folderPath)) {
+        fs.rmSync(folderPath, { recursive: true, force: true });
+      }
+      ctx.showNotification(`Dismissed reflection for ${persona.display_name}`, "info");
+      return;
+    }
+  },
+};

package/tui/src/commands/registry.ts

@@ -1,6 +1,7 @@
 import type { OverlayRenderer } from "../context/overlay";
 import type { EiContextValue } from "../context/ei";
 import type { CliRenderer } from "@opentui/core";
+import { logger } from "../util/logger";
 
 export interface Command {
   name: string;
@@ -116,6 +117,7 @@ export async function parseAndExecute(
     await command.execute(args, ctx);
   } catch (error) {
     const errorMsg = error instanceof Error ? error.message : String(error);
+    logger.error(`[command:${commandName}] ${errorMsg}`, error);
     ctx.showNotification(`Command failed: ${errorMsg}`, "error");
   }
 

package/tui/src/components/CYPTreeOverlay.tsx

@@ -31,8 +31,6 @@ interface TreeLine {
 
 function getMessageContent(m: RoomMessage): string {
   if (m.content) return m.content;
-  if (m.verbal_response) return m.verbal_response;
-  if (m.action_response) return m.action_response;
   if (m.silence_reason) return `(${m.silence_reason})`;
   return "";
 }

package/tui/src/components/MAPScoreOverlay.tsx

@@ -32,7 +32,7 @@ function truncate(s: string, n: number): string {
 }
 
 function getMessageText(m: RoomMessage): string {
-  return (m.verbal_response ?? m.content ?? m.silence_reason ?? "").replace(/\n+/g, " ");
+  return (m.content ?? m.silence_reason ?? "").replace(/\n+/g, " ");
 }
 
 export function MAPScoreOverlay(props: MAPScoreOverlayProps) {

package/tui/src/components/MessageList.tsx

@@ -19,17 +19,14 @@ function formatTime(timestamp: string): string {
   return `${hours}:${minutes}`;
 }
 
-function getContent(msg: { content?: string; verbal_response?: string; action_response?: string }): string {
-  if (msg.content) return msg.content;
-  const parts: string[] = [];
-  if (msg.action_response) parts.push(`_${msg.action_response}_`);
-  if (msg.verbal_response) parts.push(msg.verbal_response);
-  return parts.join('\n\n');
+function getContent(msg: { content?: string }): string {
+  return msg.content ?? '';
 }
 
-function buildMessageText(message: Message): string {
+function buildMessageText(message: Message, humanName: string): string {
   if (message.silence_reason !== undefined) {
-    return `[chose not to respond: ${message.silence_reason}]`;
+    const silentParty = message.role === "human" ? humanName : "Persona";
+    return `[${silentParty} chose not to respond: ${message.silence_reason}]`;
   }
   return getContent(message);
 }
@@ -128,7 +125,7 @@ export function MessageList() {
               
               const header = () => `${speaker} (${formatTime(message.timestamp)}) [✂️  ${message._quoteIndex}]:`;
               
-              const displayContent = insertQuoteMarkers(buildMessageText(message), message._quotes);
+              const displayContent = insertQuoteMarkers(buildMessageText(message, humanDisplayName()), message._quotes);
               
               const showDivider = () => {
                 const boundary = activeContextBoundary();

package/tui/src/components/PromptInput.tsx

@@ -27,6 +27,7 @@ import { authCommand } from '../commands/auth';
 import { dedupeCommand } from "../commands/dedupe";
 import { roomCommand } from "../commands/room.js";
 import { activateCommand } from "../commands/activate.js";
+import { reflectCommand } from "../commands/reflect.js";
 import { silenceCommand } from "../commands/silence.js";
 import { captureCommand } from "../commands/capture.js";
 import { openCYPEditor } from "../util/cyp-editor.js";
@@ -90,6 +91,7 @@ export function PromptInput() {
   registerCommand(resumeCommand);
   registerCommand(archiveCommand);
   registerCommand(unarchiveCommand);
+  registerCommand(reflectCommand);
 
   let textareaRef: TextareaRenderable | undefined;
 
@@ -164,7 +166,7 @@ export function PromptInput() {
         );
         const recalled = recallHumanRoomMessage();
         if (recalled) {
-          const content = pendingMsg?.verbal_response ?? pendingMsg?.silence_reason ?? "";
+          const content = pendingMsg?.content ?? pendingMsg?.silence_reason ?? "";
           textareaRef?.setText(content);
           setInputText(content);
           textareaRef?.gotoBufferEnd();

package/tui/src/components/RoomMessageList.tsx

@@ -7,12 +7,8 @@ import type { RoomMessage, Quote } from "../../../src/core/types.js";
 import { RoomMode } from "../../../src/core/types/enums.js";
 import { insertQuoteMarkers } from "../util/quote-utils.js";
 
-function getContent(msg: { content?: string; verbal_response?: string; action_response?: string }): string {
-  if (msg.content) return msg.content;
-  const parts: string[] = [];
-  if (msg.action_response) parts.push(`_${msg.action_response}_`);
-  if (msg.verbal_response) parts.push(msg.verbal_response);
-  return parts.join('\n\n');
+function getContent(msg: { content?: string }): string {
+  return msg.content ?? '';
 }
 
 interface RoomMessageWithQuotes extends RoomMessage {

package/tui/src/components/Sidebar.tsx

@@ -25,11 +25,8 @@ export function Sidebar() {
     personas().filter(p => !p.is_archived)
   );
 
-  // Memoize visible (non-archived) rooms sorted by last_activity desc
   const visibleRooms = createMemo(() =>
-    rooms()
-      .filter((r: RoomSummary) => !r.is_archived)
-      .sort((a: RoomSummary, b: RoomSummary) => b.last_activity.localeCompare(a.last_activity))
+    rooms().filter((r: RoomSummary) => !r.is_archived)
   );
 
   const [highlightedPersona, setHighlightedPersona] = createSignal<string | null>(null);
@@ -79,7 +76,8 @@ export function Sidebar() {
                 const name = displayName();
                 const unread = persona.unread_count > 0 ? ` (${persona.unread_count} new)` : "";
                 const paused = persona.is_paused ? " ⏸" : "";
-                return `${prefix}${name}${unread}${paused}`;
+                const reflect = persona.has_pending_update ? " ✦" : "";
+                return `${prefix}${name}${unread}${paused}${reflect}`;
               };
 
               const textColor = () => {

package/tui/src/components/StatusBar.tsx

@@ -133,22 +133,34 @@ export function StatusBar() {
     >
       <box flexGrow={1}>
         <Show when={notification()} fallback={
-          <Show when={activeRoomId()} fallback={
-            <text fg="#586e75">
-              <Show when={getActiveDisplayName()} fallback="No persona selected">
-                {getActiveDisplayName()}
+          <Show
+            when={(() => {
+              const id = activePersonaId();
+              return id ? personas().find(p => p.id === id)?.has_pending_update : false;
+            })()}
+            fallback={
+              <Show when={activeRoomId()} fallback={
+                <text fg="#586e75">
+                  <Show when={getActiveDisplayName()} fallback="No persona selected">
+                    {getActiveDisplayName()}
+                  </Show>
+                </text>
+              }>
+                <Show when={allPersonasResponded() && humanRoomMessagePending()} fallback={
+                  <text fg="#586e75">
+                    {getRoomWaitingText()}
+                  </text>
+                }>
+                  <text fg="#586e75">
+                    {activeRoom()?.display_name ?? ""}
+                  </text>
+                </Show>
               </Show>
+            }
+          >
+            <text fg="#b58900">
+              {`✦ Reflection ready for ${getActiveDisplayName()} — /reflect to learn more`}
             </text>
-          }>
-            <Show when={allPersonasResponded() && humanRoomMessagePending()} fallback={
-              <text fg="#586e75">
-                {getRoomWaitingText()}
-              </text>
-            }>
-              <text fg="#586e75">
-                {activeRoom()?.display_name ?? ""}
-              </text>
-            </Show>
           </Show>
         }>
           <text fg={getNotificationColor()}>

package/tui/src/context/keyboard.tsx

@@ -178,7 +178,7 @@ export const KeyboardProvider: ParentComponent = (props) => {
         }
       }
       // Navigate backward through sent-message history
-        const history = messages().filter(m => m.role === "human").map(m => (m.content ?? m.verbal_response ?? ''));
+        const history = messages().filter(m => m.role === "human").map(m => (m.content ?? ''));
       if (history.length === 0) return;
       if (historyIndex === -1) {
         savedDraft = textareaRef.plainText;
@@ -206,7 +206,7 @@ export const KeyboardProvider: ParentComponent = (props) => {
         textareaRef.gotoBufferEnd();
       } else {
         historyIndex -= 1;
-      const history = messages().filter(m => m.role === "human").map(m => (m.content ?? m.verbal_response ?? ''));
+      const history = messages().filter(m => m.role === "human").map(m => (m.content ?? ''));
         const entry = history[history.length - 1 - historyIndex];
         textareaRef.setText(entry);
         textareaRef.gotoBufferEnd();  // cursor at end so next Down continues forward

package/tui/src/util/cyp-editor.tsx

@@ -7,12 +7,8 @@ interface ParsedBlock {
   chosen: boolean;
 }
 
-function getContent(m: { content?: string; verbal_response?: string; action_response?: string }): string {
-  if (m.content) return m.content;
-  const parts: string[] = [];
-  if (m.action_response) parts.push(`_${m.action_response}_`);
-  if (m.verbal_response) parts.push(m.verbal_response);
-  return parts.join('\n\n');
+function getContent(m: { content?: string }): string {
+  return m.content ?? '';
 }
 
 export function buildCYPEditorYAML(

package/tui/src/util/yaml-context.ts

@@ -12,12 +12,8 @@ interface EditableMessage {
   silence_reason?: string;
 }
 
-function getContent(m: { content?: string; verbal_response?: string; action_response?: string }): string {
-  if (m.content) return m.content;
-  const parts: string[] = [];
-  if (m.action_response) parts.push(`_${m.action_response}_`);
-  if (m.verbal_response) parts.push(m.verbal_response);
-  return parts.join('\n\n');
+function getContent(m: { content?: string }): string {
+  return m.content ?? '';
 }
 
 export function contextToYAML(messages: Message[]): string {

package/tui/src/util/yaml-persona.ts

@@ -214,15 +214,15 @@ export function personaToYAML(persona: PersonaEntity, allGroups?: string[], allT
       : persona.traits.map(({ name, description, sentiment, strength }) => ({ name, description, sentiment: sentiment ?? 0, strength: strength ?? 0.5 })),
     topics: useTopicPlaceholder
       ? [PLACEHOLDER_TOPIC]
-      : persona.topics.map(({ name, perspective, approach, personal_stake, exposure_current, exposure_desired }) => ({
-          name, perspective, approach, personal_stake, exposure_current, exposure_desired
+      : persona.topics.map(({ name, perspective, approach, personal_stake, sentiment, exposure_current, exposure_desired }) => ({
+          name, perspective, approach, personal_stake, sentiment: sentiment ?? 0, exposure_current, exposure_desired
         })),
     heartbeat_delay_ms: persona.heartbeat_delay_ms ? formatDuration(persona.heartbeat_delay_ms) : null,
     context_window_hours: persona.context_window_hours ?? null,
     is_paused: persona.is_paused || undefined,
     pause_until: persona.pause_until,
     is_static: persona.is_static || undefined,
-    include_message_timestamps: persona.include_message_timestamps || undefined,
+    include_message_timestamps: persona.include_message_timestamps ?? false,
     tools: toolsMap,
   };
 

package/tui/src/util/yaml-settings.ts

@@ -14,7 +14,6 @@ interface EditableSettingsData {
   default_model?: string | null;
   oneshot_model?: string | null;
   rewrite_model?: string | null;
-  time_mode?: "24h" | "12h" | "local" | "utc" | null;
   name_display?: string | null;
   default_heartbeat_ms?: string | null;
   default_context_window_hours?: number | null;
@@ -64,7 +63,6 @@ export function settingsToYAML(settings: HumanSettings | undefined, accounts: Pr
     default_model: guidToDisplay(settings?.default_model),
     oneshot_model: guidToDisplay(settings?.oneshot_model),
     rewrite_model: guidToDisplay(settings?.rewrite_model),
-    time_mode: settings?.time_mode ?? null,
     name_display: settings?.name_display ?? null,
     default_heartbeat_ms: formatDuration(settings?.default_heartbeat_ms ?? 1800000),
     default_context_window_hours: settings?.default_context_window_hours ?? 8,
@@ -190,7 +188,6 @@ export function settingsFromYAML(yamlContent: string, original: HumanSettings |
     default_model: displayToGuid(data.default_model),
     oneshot_model: displayToGuid(data.oneshot_model),
     rewrite_model: displayToGuid(data.rewrite_model),
-    time_mode: nullToUndefined(data.time_mode),
     name_display: nullToUndefined(data.name_display),
     default_heartbeat_ms: parseMsDuration(data.default_heartbeat_ms, 1800000),
     default_context_window_hours: nullToUndefined(data.default_context_window_hours),