@llblab/pi-telegram 0.11.1 → 0.11.2

package/index.ts

@@ -11,7 +11,6 @@ import * as Config from "./lib/config.ts";
 import {
   createTelegramExtensionSectionRegistry,
   setGlobalTelegramSectionRegistry,
-  registerTelegramSection,
   type TelegramSectionRegistry,
 } from "./lib/extension-sections.ts";
 import { createTelegramExternalHandleUpdate } from "./lib/external-handlers.ts";
@@ -46,42 +45,6 @@ const VOICE_EVENT_RECORDER_KEY = "__piTelegramVoiceEventRecorder__";
 type ActivePiModel = NonNullable<Pi.ExtensionContext["model"]>;
 type RuntimeTelegramQueueItem = Queue.TelegramQueueItem<Pi.ExtensionContext>;
 
-export {
-  registerTelegramOutboundHandler,
-  hasTelegramOutboundHandler,
-  getTelegramOutboundProgrammaticHandlers,
-  recordTelegramRuntimeEvent,
-} from "./lib/outbound-handlers.ts";
-
-// --- Voice Integration Exports ---
-// Prefer domain imports from ./lib/voice.ts; root exports stay for compatibility.
-export {
-  registerTelegramVoiceSynthesisProvider,
-  getTelegramVoiceSynthesisProviders,
-  hasTelegramVoiceSynthesisProvider,
-  clearTelegramVoiceSynthesisProviders,
-  planTelegramVoiceReply,
-  getTelegramVoiceReplyMode,
-  computeVoiceTurnFlags,
-  isVoiceTurn,
-  shouldSuppressPreviewForVoice,
-  computeVoicePromptContribution,
-  type TelegramVoiceSynthesisProvider,
-  type TelegramVoiceTurnView,
-  type TelegramVoiceSynthesisProviderResult,
-  type TelegramVoiceReplyMode,
-} from "./lib/voice.ts";
-
-// --- Extension Section Exports ---
-export {
-  registerTelegramSection,
-  type TelegramSectionRegistration,
-  type TelegramSectionContext,
-  type TelegramSectionCallbackContext,
-  type TelegramSectionView,
-  type TelegramSectionSettingsRegistration,
-} from "./lib/extension-sections.ts";
-
 // --- Extension Runtime ---
 
 export default function (pi: Pi.ExtensionAPI) {
@@ -99,7 +62,10 @@ export default function (pi: Pi.ExtensionAPI) {
   Config.setGlobalTelegramConfigRuntime({
     updateVoiceConfig(voice) {
       const current = configStore.get();
-      const next = { ...current, voice: { ...(current.voice ?? {}), ...voice } };
+      const next = {
+        ...current,
+        voice: { ...(current.voice ?? {}), ...voice },
+      };
       configStore.set(next);
       void configStore.persist(next);
     },
@@ -137,7 +103,6 @@ export default function (pi: Pi.ExtensionAPI) {
     createTelegramExtensionSectionRegistry();
   setGlobalTelegramSectionRegistry(sectionRegistry);
 
-
   const runtimeEvents = Status.createTelegramRuntimeEventRecorder({
     getBotToken: configStore.getBotToken,
   });
@@ -146,9 +111,8 @@ export default function (pi: Pi.ExtensionAPI) {
     getConfig: Config.createTelegramTimeConfigGetter(configStore),
     recordRuntimeEvent,
   });
-  (globalThis as Record<string, unknown>)[
-    VOICE_EVENT_RECORDER_KEY
-  ] = recordRuntimeEvent;
+  (globalThis as Record<string, unknown>)[VOICE_EVENT_RECORDER_KEY] =
+    recordRuntimeEvent;
   const getContextModel = Pi.getExtensionContextModel;
   const isIdle = Pi.isExtensionContextIdle;
   const hasPendingMessages = Pi.hasExtensionContextPendingMessages;
@@ -165,6 +129,7 @@ export default function (pi: Pi.ExtensionAPI) {
     Queue.createTelegramQueueStore<Pi.ExtensionContext>();
   const deferredQueueDispatchRuntime =
     Queue.createTelegramDeferredQueueDispatchRuntime<Pi.ExtensionContext>({
+      delayMs: 50,
       recordRuntimeEvent,
     });
   const pollingControllerState = Polling.createTelegramPollingControllerState();
@@ -623,9 +588,23 @@ export default function (pi: Pi.ExtensionAPI) {
   const agentStartWithDedupReset = Lifecycle.createAgentStartDedupHook(
     agentLifecycleHooks.onAgentStart,
   );
+  const compactionObserver = Lifecycle.createTelegramCompactionObserverRuntime({
+    setCompactionInProgress: lifecycle.setCompactionInProgress,
+    updateStatus,
+    requestDeferredDispatchNextQueuedTelegramTurn:
+      deferredQueueDispatchRuntime.request,
+    dispatchNextQueuedTelegramTurn,
+    recordRuntimeEvent,
+  });
   Lifecycle.registerTelegramLifecycleHooks(pi, {
     ...sessionLifecycleRuntime,
     ...agentLifecycleHooks,
+    async onSessionShutdown(event, ctx) {
+      compactionObserver.onSessionShutdown();
+      await sessionLifecycleRuntime.onSessionShutdown(event, ctx);
+    },
+    onSessionBeforeCompact: compactionObserver.onSessionBeforeCompact,
+    onSessionCompact: compactionObserver.onSessionCompact,
     onAgentStart: agentStartWithDedupReset,
     onBeforeAgentStart: Prompts.createTelegramProactiveBeforeAgentStartHook({
       isProactivePushEnabled,

package/lib/command-templates.ts

@@ -8,9 +8,8 @@ import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { isAbsolute, resolve } from "node:path";
 
-export const DEFAULT_COMMAND_TIMEOUT_MS = 30_000;
-
 export type CommandTemplateMode = "sequence" | "parallel";
+export type CommandTemplateFailureScope = "continue" | "branch" | "root";
 
 export interface CommandTemplateObjectConfig {
   label?: string;
@@ -23,7 +22,9 @@ export interface CommandTemplateObjectConfig {
   output?: string;
   retry?: number;
   critical?: boolean;
-  repeat?: number;
+  failure?: CommandTemplateFailureScope;
+  recover?: CommandTemplateValue;
+  repeat?: number | string;
 }
 
 export type CommandTemplateValue = string | CommandTemplateConfig[] | CommandTemplateObjectConfig;
@@ -72,23 +73,92 @@ export function normalizeCommandTemplateConfig(
   return typeof config === "string" ? { template: config } : config;
 }
 
+function normalizeRecoverConfig(
+  config: CommandTemplateValue | undefined,
+): CommandTemplateConfig | undefined {
+  if (config === undefined) return undefined;
+  return Array.isArray(config) ? { template: config } : config;
+}
+
 function normalizeCommandTemplateDefaults(
   defaults: Record<string, unknown> | undefined,
 ): Record<string, unknown> | undefined {
   if (!defaults) return undefined;
   const normalized: Record<string, unknown> = {};
   for (const [key, value] of Object.entries(defaults)) {
-    normalized[key] =
-      value === undefined || value === null ? "" : String(value);
+    normalized[key] = Array.isArray(value)
+      ? value
+      : value === undefined || value === null ? "" : String(value);
   }
   return normalized;
 }
 
-function normalizeRepeat(value: number | undefined): number | undefined {
+export function resolveCommandTemplateRepeat(
+  value: number | string | undefined,
+  values: Record<string, unknown> = {},
+): number | undefined {
   if (value === undefined) return undefined;
-  if (!Number.isInteger(value) || value < 1)
-    throw new Error("Command template repeat must be a positive integer.");
-  return value;
+  if (typeof value === "number") {
+    if (!Number.isInteger(value) || value < 1)
+      throw new Error("Command template repeat must be a positive integer.");
+    return value;
+  }
+  const trimmed = value.trim();
+  if (/^\d+$/.test(trimmed)) return Number(trimmed);
+  const lengthMatch = trimmed.match(/^\{?([A-Za-z_][A-Za-z0-9_-]*)\.length\}?$/);
+  if (lengthMatch) {
+    const source = values[lengthMatch[1]];
+    if (Array.isArray(source)) return source.length;
+    if (source === undefined) return undefined;
+  }
+  throw new Error("Command template repeat must be a positive integer or {array.length}.");
+}
+
+function getExecutableName(command: string | undefined): string {
+  if (!command) return "";
+  return command.split(/[\\/]/).pop()?.toLowerCase() ?? "";
+}
+
+function hasAnyFlag(args: string[], flags: string[]): boolean {
+  return args.some((arg) => flags.includes(arg));
+}
+
+function hasRiskyPathArg(args: string[]): boolean {
+  return args.some((arg) =>
+    arg === "/" ||
+    arg === "~" ||
+    arg === "./" ||
+    arg === "../" ||
+    arg.includes("{") ||
+    arg.startsWith("~/") ||
+    arg.startsWith("/"),
+  );
+}
+
+function getLeafCommandTemplateWarnings(
+  config: CommandTemplateLeafConfig,
+): string[] {
+  const parts = splitCommandTemplate(config.template);
+  const command = getExecutableName(parts[0]);
+  const args = parts.slice(1);
+  const warnings: string[] = [];
+  if (["bash", "sh", "zsh", "fish"].includes(command)) {
+    const mode = hasAnyFlag(args, ["-c"]) ? "shell command strings" : "shell scripts";
+    warnings.push(`${config.label ?? command}: invokes ${command}; ${mode} are trusted executable content and are not sandboxed by command-template argv splitting.`);
+  }
+  if (["node", "deno", "bun"].includes(command) && hasAnyFlag(args, ["-e", "--eval"])) {
+    warnings.push(`${config.label ?? command}: invokes ${command} eval mode; code strings are trusted executable content and are not sandboxed.`);
+  }
+  if (["python", "python3", "perl", "ruby"].includes(command) && hasAnyFlag(args, ["-c", "-e"])) {
+    warnings.push(`${config.label ?? command}: invokes ${command} code-eval mode; code strings are trusted executable content and are not sandboxed.`);
+  }
+  if (command === "rm" && (args.some((arg) => /^-[^-]*r/.test(arg) || /^-[^-]*f/.test(arg)) || hasRiskyPathArg(args))) {
+    warnings.push(`${config.label ?? command}: removes filesystem paths; verify placeholders and paths before running trusted destructive commands.`);
+  }
+  if (["mv", "cp", "rsync"].includes(command) && hasRiskyPathArg(args)) {
+    warnings.push(`${config.label ?? command}: mutates broad filesystem paths; verify placeholders and paths before running trusted commands.`);
+  }
+  return warnings;
 }
 
 function pad(value: number, width: number): string {
@@ -124,7 +194,7 @@ function expandRepeatConfig(
   config: CommandTemplateObjectConfig,
   context: Pick<CommandTemplateObjectConfig, "args" | "defaults">,
 ): CommandTemplateObjectConfig[] | undefined {
-  const repeat = normalizeRepeat(config.repeat);
+  const repeat = resolveCommandTemplateRepeat(config.repeat, context.defaults ?? {});
   if (repeat === undefined) return undefined;
   return Array.from({ length: repeat }, (_unused, index0) => {
     const { repeat: _repeat, ...rest } = config;
@@ -164,12 +234,19 @@ export function expandCommandTemplateConfigs(
   if (repeated) {
     return repeated.flatMap((step) => expandCommandTemplateConfigs(step, context));
   }
+  const recoverConfig = normalizeRecoverConfig(normalizedConfig.recover);
+  const recoverSteps = recoverConfig
+    ? expandCommandTemplateConfigs(recoverConfig, context)
+    : [];
   if (Array.isArray(normalizedConfig.template)) {
-    return normalizedConfig.template.flatMap((step) =>
-      expandCommandTemplateConfigs(step, context),
-    );
+    return [
+      ...normalizedConfig.template.flatMap((step) =>
+        expandCommandTemplateConfigs(step, context),
+      ),
+      ...recoverSteps,
+    ];
   }
-  if (typeof normalizedConfig.template !== "string") return [];
+  if (typeof normalizedConfig.template !== "string") return recoverSteps;
   return [
     {
       ...normalizedConfig,
@@ -178,9 +255,37 @@ export function expandCommandTemplateConfigs(
       retry: normalizedConfig.retry,
       critical: normalizedConfig.critical,
     },
+    ...recoverSteps,
   ];
 }
 
+export function getCommandTemplateWarnings(
+  config: CommandTemplateConfig,
+): string[] {
+  return [
+    ...new Set(
+      expandCommandTemplateConfigs(config)
+        .flatMap((leaf) => getLeafCommandTemplateWarnings(leaf)),
+    ),
+  ];
+}
+
+function parseCommandTemplateArgToken(value: string): { name: string; defaultValue?: string } {
+  const separatorIndex = value.indexOf("=");
+  const rawName = separatorIndex === -1 ? value : value.slice(0, separatorIndex);
+  const colonIndex = rawName.indexOf(":");
+  return {
+    name: (colonIndex === -1 ? rawName : rawName.slice(0, colonIndex)).trim(),
+    ...(separatorIndex === -1 ? {} : { defaultValue: value.slice(separatorIndex + 1).trim() }),
+  };
+}
+
+function parseCommandTemplatePlaceholderContent(content: string): { name: string; inlineDefault?: string } | undefined {
+  const match = content.match(/^([A-Za-z_][A-Za-z0-9_-]*)(?::(?:string|path|int|number|bool|array|enum\([^)]*\)))?(?:=([^}]*))?$/);
+  if (!match) return undefined;
+  return { name: match[1], ...(match[2] !== undefined ? { inlineDefault: match[2] } : {}) };
+}
+
 export function getCommandTemplateDefaults(
   config: CommandTemplateConfig | undefined,
 ): Record<string, string> {
@@ -190,9 +295,9 @@ export function getCommandTemplateDefaults(
   const defaults: Record<string, string> = {};
   for (const item of normalizeCommandTemplateArgs(normalizedConfig?.args)) {
     if (!item) continue;
-    const [name, ...defaultParts] = item.split("=");
-    if (!name || defaultParts.length === 0) continue;
-    defaults[name.trim()] = defaultParts.join("=").trim();
+    const parsed = parseCommandTemplateArgToken(item);
+    if (!parsed.name || parsed.defaultValue === undefined) continue;
+    defaults[parsed.name] = parsed.defaultValue;
   }
   for (const [key, value] of Object.entries(normalizedConfig?.defaults ?? {})) {
     defaults[key] = value === undefined || value === null ? "" : String(value);
@@ -256,7 +361,7 @@ export function expandCommandTemplateExecutable(
 
 function evaluateCommandTemplateExpression(
   expression: string,
-  values: Record<string, string>,
+  values: Record<string, unknown>,
 ): number {
   let index = 0;
   const source = expression.replace(/\s+/g, "");
@@ -283,7 +388,7 @@ function evaluateCommandTemplateExpression(
     if (nameMatch) {
       index += nameMatch[0].length;
       const value = values[nameMatch[0]];
-      if (value === undefined || !/^-?\d+$/.test(value))
+      if (value === undefined || !/^-?\d+$/.test(String(value)))
         throw new Error(`Invalid command template expression variable: ${nameMatch[0]}`);
       return Number(value);
     }
@@ -313,7 +418,7 @@ function evaluateCommandTemplateExpression(
 
 function substituteCommandTemplateExpression(
   content: string,
-  values: Record<string, string>,
+  values: Record<string, unknown>,
 ): string | undefined {
   const padded = content.match(/^(_{1,6})\((.+)\)$/);
   if (padded) {
@@ -323,22 +428,50 @@ function substituteCommandTemplateExpression(
   return String(evaluateCommandTemplateExpression(content, values));
 }
 
+function resolveCommandTemplateValue(
+  content: string,
+  values: Record<string, unknown>,
+  missingLabel: string,
+  depth = 0,
+): string | undefined {
+  if (depth > 5) throw new Error(`Command template value recursion exceeded: ${content}`);
+  const indexed = content.match(/^([A-Za-z_][A-Za-z0-9_-]*)\[([A-Za-z_][A-Za-z0-9_-]*|\d+)\]$/);
+  if (indexed) {
+    const source = values[indexed[1]];
+    const indexValue = /^\d+$/.test(indexed[2]) ? indexed[2] : values[indexed[2]];
+    const index = Number(indexValue);
+    if (!Array.isArray(source) || !Number.isInteger(index) || index < 0 || index >= source.length) {
+      throw new Error(`Missing ${missingLabel} value: ${content}`);
+    }
+    return String(source[index] ?? "");
+  }
+  const simple = parseCommandTemplatePlaceholderContent(content);
+  if (simple) {
+    if (Object.hasOwn(values, simple.name)) {
+      const raw = values[simple.name] ?? "";
+      if (typeof raw === "string" && /^\{[^{}]+\}$/.test(raw)) {
+        return substituteCommandTemplateToken(raw, values, missingLabel, depth + 1);
+      }
+      return Array.isArray(raw) ? JSON.stringify(raw) : String(raw);
+    }
+    if (simple.inlineDefault !== undefined) return simple.inlineDefault;
+  }
+  const expression = substituteCommandTemplateExpression(content, values);
+  if (expression !== undefined) return expression;
+  return undefined;
+}
+
 export function substituteCommandTemplateToken(
   token: string,
-  values: Record<string, string>,
+  values: Record<string, unknown>,
   missingLabel = "command template",
+  depth = 0,
 ): string {
   return token.replace(
     /\{([^{}]+)\}/g,
     (_match, content: string) => {
-      const simple = content.match(/^([A-Za-z_][A-Za-z0-9_-]*)(?:=([^}]*))?$/);
-      if (simple) {
-        const [, name, inlineDefault] = simple;
-        if (Object.hasOwn(values, name)) return values[name] ?? "";
-        if (inlineDefault !== undefined) return inlineDefault;
-      }
-      const expression = substituteCommandTemplateExpression(content, values);
-      if (expression !== undefined) return expression;
+      const resolved = resolveCommandTemplateValue(content, values, missingLabel, depth);
+      if (resolved !== undefined) return resolved;
       throw new Error(`Missing ${missingLabel} value: ${content}`);
     },
   );
@@ -405,8 +538,6 @@ function execCommandTemplateOnce(
     }
     if (options.timeout !== undefined && options.timeout > 0)
       timeoutId = setTimeout(killProcess, options.timeout);
-    else if (options.timeout === undefined)
-      timeoutId = setTimeout(killProcess, DEFAULT_COMMAND_TIMEOUT_MS);
     proc.stdout?.on("data", (data) => {
       stdout += data.toString();
     });
@@ -427,7 +558,7 @@ function execCommandTemplateOnce(
 
 export function buildCommandTemplateInvocation(
   config: CommandTemplateConfig,
-  values: Record<string, string>,
+  values: Record<string, unknown>,
   cwd: string,
   options: { emptyMessage?: string; missingLabel?: string } = {},
 ): CommandTemplateInvocation {

package/lib/config.ts

@@ -35,7 +35,7 @@ export interface TelegramOutboundHandlerConfig extends CommandTemplateObjectConf
   timeout?: number;
 }
 
-export type TelegramTimeMode = "off" | "always" | "interval";
+export type TelegramTimeMode = "hidden" | "always" | "interval";
 
 export interface TelegramTimeConfig {
   injectionMode?: TelegramTimeMode;
@@ -240,7 +240,7 @@ export function resolveTelegramTimeConfig(
   const injectionMode: TelegramTimeMode =
     raw?.injectionMode === "always" || raw?.injectionMode === "interval"
       ? raw.injectionMode
-      : "off";
+      : "hidden";
   const interval =
     typeof raw?.interval === "number" && raw.interval > 0
       ? raw.interval

package/lib/lifecycle.ts

@@ -10,6 +10,8 @@ import type {
   BeforeAgentStartEvent,
   ExtensionAPI,
   ExtensionContext,
+  SessionBeforeCompactEvent,
+  SessionCompactEvent,
   SessionShutdownEvent,
   SessionStartEvent,
 } from "./pi.ts";
@@ -50,6 +52,14 @@ export interface TelegramLifecycleRegistrationDeps {
     event: SessionShutdownEvent,
     ctx: ExtensionContext,
   ) => Promise<void>;
+  onSessionBeforeCompact?: (
+    event: SessionBeforeCompactEvent,
+    ctx: ExtensionContext,
+  ) => Promise<void> | void;
+  onSessionCompact?: (
+    event: SessionCompactEvent,
+    ctx: ExtensionContext,
+  ) => Promise<void> | void;
   onBeforeAgentStart: (
     event: BeforeAgentStartEvent,
     ctx: ExtensionContext,
@@ -92,6 +102,76 @@ export interface TelegramSessionLifecycleHooks {
   ) => Promise<void>;
 }
 
+type TelegramLifecycleTimer = number | ReturnType<typeof setTimeout>;
+
+export interface TelegramCompactionObserverRuntimeDeps<TContext> {
+  setCompactionInProgress: (inProgress: boolean) => void;
+  updateStatus: (ctx: TContext) => void;
+  requestDeferredDispatchNextQueuedTelegramTurn: (
+    dispatch: (ctx: TContext) => void,
+  ) => void;
+  dispatchNextQueuedTelegramTurn: (ctx: TContext) => void;
+  recordRuntimeEvent?: (category: string, error: unknown) => void;
+  timeoutMs?: number;
+  setTimer?: (
+    callback: () => void,
+    ms: number,
+  ) => TelegramLifecycleTimer;
+  clearTimer?: (timer: TelegramLifecycleTimer) => void;
+}
+
+export interface TelegramCompactionObserverRuntime<TContext> {
+  onSessionBeforeCompact: (
+    event: SessionBeforeCompactEvent,
+    ctx: TContext,
+  ) => void;
+  onSessionCompact: (event: SessionCompactEvent, ctx: TContext) => void;
+  onSessionShutdown: () => void;
+}
+
+export function createTelegramCompactionObserverRuntime<TContext>(
+  deps: TelegramCompactionObserverRuntimeDeps<TContext>,
+): TelegramCompactionObserverRuntime<TContext> {
+  const timeoutMs = deps.timeoutMs ?? 300_000;
+  const setTimer = deps.setTimer ?? setTimeout;
+  const clearTimer = deps.clearTimer ?? clearTimeout;
+  let fallbackTimer: TelegramLifecycleTimer | undefined;
+  const clearFallbackTimer = (): void => {
+    if (!fallbackTimer) return;
+    clearTimer(fallbackTimer);
+    fallbackTimer = undefined;
+  };
+  const requestDispatch = (): void => {
+    deps.requestDeferredDispatchNextQueuedTelegramTurn(
+      deps.dispatchNextQueuedTelegramTurn,
+    );
+  };
+  return {
+    onSessionBeforeCompact: (_event, ctx) => {
+      deps.setCompactionInProgress(true);
+      deps.updateStatus(ctx);
+      clearFallbackTimer();
+      fallbackTimer = setTimer(() => {
+        fallbackTimer = undefined;
+        deps.setCompactionInProgress(false);
+        deps.updateStatus(ctx);
+        deps.recordRuntimeEvent?.(
+          "compact",
+          new Error("Compaction observer timed out"),
+        );
+        requestDispatch();
+      }, timeoutMs);
+    },
+    onSessionCompact: (_event, ctx) => {
+      clearFallbackTimer();
+      deps.setCompactionInProgress(false);
+      deps.updateStatus(ctx);
+      requestDispatch();
+    },
+    onSessionShutdown: clearFallbackTimer,
+  };
+}
+
 export function createDedupAgentStartHook(
   dedup: { reset(): void },
   inner: (event: AgentStartEvent, ctx: ExtensionContext) => Promise<void>,
@@ -139,6 +219,12 @@ export function registerTelegramLifecycleHooks(
   pi.on("session_shutdown", async (event, ctx) => {
     await deps.onSessionShutdown(event, ctx);
   });
+  pi.on("session_before_compact", async (event, ctx) => {
+    await deps.onSessionBeforeCompact?.(event, ctx);
+  });
+  pi.on("session_compact", async (event, ctx) => {
+    await deps.onSessionCompact?.(event, ctx);
+  });
   pi.on("before_agent_start", async (event, ctx) => {
     return deps.onBeforeAgentStart(event, ctx);
   });

package/lib/menu-settings.ts

@@ -135,17 +135,24 @@ export function buildTelegramSettingsMenuText(): string {
   return SETTINGS_MENU_TITLE;
 }
 
-export function buildProactivePushSettingsText(): string {
+export function buildProactivePushSettingsText(
+  proactivePushEnabled: boolean,
+): string {
   return [
-    PROACTIVE_PUSH_SETTINGS_TITLE,
+    `${PROACTIVE_PUSH_SETTINGS_TITLE} <code>${proactivePushEnabled ? "on" : "off"}</code>`,
     "",
     "Send successful local π task results to Telegram when the bridge is connected.",
   ].join("\n");
 }
 
-export function buildVoiceReplyModeSettingsText(): string {
+export function buildVoiceReplyModeSettingsText(
+  mode: TelegramVoiceReplyMode,
+  configured = true,
+): string {
   return [
-    VOICE_REPLY_MODE_SETTINGS_TITLE,
+    `${VOICE_REPLY_MODE_SETTINGS_TITLE} <code>${getVoiceReplyModeLabel(
+      getVoiceReplyModeSetting(mode, configured),
+    )}</code>`,
     "",
     "Controls when pi-telegram converts assistant text replies into Telegram voice messages.",
     "",
@@ -156,13 +163,15 @@ export function buildVoiceReplyModeSettingsText(): string {
   ].join("\n");
 }
 
-export function buildTimeInjectionModeSettingsText(): string {
+export function buildTimeInjectionModeSettingsText(
+  mode: TelegramTimeMode,
+): string {
   return [
-    TIME_INJECTION_MODE_SETTINGS_TITLE,
+    `${TIME_INJECTION_MODE_SETTINGS_TITLE} <code>${mode}</code>`,
     "",
     "Controls whether Telegram-originated prompts include a compact wall-clock [time] line.",
     "",
-    "<code>-</code> <code>off</code> (default): no time line is added.",
+    "<code>-</code> <code>hidden</code> (default): no time line is added to prompt context.",
     "<code>-</code> <code>always</code>: add time to every Telegram turn.",
     "<code>-</code> <code>interval</code>: add time at most once per chat interval (default: 1 hour).",
   ].join("\n");
@@ -257,7 +266,7 @@ export function buildProactivePushSettingsReplyMarkup(
 export function buildTimeInjectionModeSettingsReplyMarkup(
   mode: TelegramTimeMode,
 ): TelegramSettingsMenuReplyMarkup {
-  const modes: TelegramTimeMode[] = ["off", "always", "interval"];
+  const modes: TelegramTimeMode[] = ["hidden", "always", "interval"];
   return {
     inline_keyboard: [
       [{ text: "⬆️ Back", callback_data: "settings:list" }],
@@ -314,30 +323,31 @@ export async function updateTelegramSettingsMenuMessage(
 export async function updateProactivePushSettingsMessage(
   deps: TelegramSettingsMenuCallbackDeps,
 ): Promise<void> {
+  const proactivePushEnabled = deps.isProactivePushEnabled();
   await deps.updateSettingsMessage(
-    buildProactivePushSettingsText(),
-    buildProactivePushSettingsReplyMarkup(deps.isProactivePushEnabled()),
+    buildProactivePushSettingsText(proactivePushEnabled),
+    buildProactivePushSettingsReplyMarkup(proactivePushEnabled),
   );
 }
 
 export async function updateTimeInjectionModeSettingsMessage(
   deps: TelegramSettingsMenuCallbackDeps,
 ): Promise<void> {
+  const mode = deps.getTimeInjectionMode();
   await deps.updateSettingsMessage(
-    buildTimeInjectionModeSettingsText(),
-    buildTimeInjectionModeSettingsReplyMarkup(deps.getTimeInjectionMode()),
+    buildTimeInjectionModeSettingsText(mode),
+    buildTimeInjectionModeSettingsReplyMarkup(mode),
   );
 }
 
 export async function updateVoiceReplyModeSettingsMessage(
   deps: TelegramSettingsMenuCallbackDeps,
 ): Promise<void> {
+  const mode = deps.getVoiceReplyMode();
+  const configured = deps.isVoiceReplyModeConfigured();
   await deps.updateSettingsMessage(
-    buildVoiceReplyModeSettingsText(),
-    buildVoiceReplyModeSettingsReplyMarkup(
-      deps.getVoiceReplyMode(),
-      deps.isVoiceReplyModeConfigured(),
-    ),
+    buildVoiceReplyModeSettingsText(mode, configured),
+    buildVoiceReplyModeSettingsReplyMarkup(mode, configured),
   );
 }
 
@@ -391,10 +401,18 @@ export async function handleTelegramSettingsMenuCallbackAction(
     const mode = data.startsWith("settings:set:time-injection:")
       ? data.slice("settings:set:time-injection:".length)
       : data.slice("settings:set:time:".length);
-    if (mode === "off" || mode === "always" || mode === "interval") {
-      await deps.setTimeInjectionMode(mode);
+    const normalizedMode = mode === "off" ? "hidden" : mode;
+    if (
+      normalizedMode === "hidden" ||
+      normalizedMode === "always" ||
+      normalizedMode === "interval"
+    ) {
+      await deps.setTimeInjectionMode(normalizedMode);
       await updateTimeInjectionModeSettingsMessage(deps);
-      await deps.answerCallbackQuery(callbackQueryId, `Time injection: ${mode}`);
+      await deps.answerCallbackQuery(
+        callbackQueryId,
+        `Time injection: ${normalizedMode}`,
+      );
       return true;
     }
   }
@@ -490,13 +508,15 @@ export function createTelegramSettingsMenuRuntime<
         if (
           (hasTimeInjectionPrefix || query.data.startsWith("settings:set:time:")) &&
           (timeMode === "off" ||
+            timeMode === "hidden" ||
             timeMode === "always" ||
             timeMode === "interval")
         ) {
-          await deps.setTimeInjectionMode(timeMode);
+          const normalizedMode = timeMode === "off" ? "hidden" : timeMode;
+          await deps.setTimeInjectionMode(normalizedMode);
           await deps.answerCallbackQuery(
             query.id,
-            `Time injection: ${timeMode}`,
+            `Time injection: ${normalizedMode}`,
           );
           return true;
         }