pi-sessions 0.9.0 → 0.11.0

package/extensions/session-auto-title/generate.ts

@@ -1,13 +1,10 @@
-import { appendFileSync, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import type { Api, Model, TextContent, UserMessage } from "@earendil-works/pi-ai";
 import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
 import type { AutoTitleContext } from "./context.ts";
+import { type AutoTitleRun, startAutoTitleRun } from "./runs.ts";
 import type { AutoTitleTrigger } from "./state.ts";
 
-const AUTO_TITLE_MAX_TOKENS = 64;
 const AUTO_TITLE_CHAR_MAX = 80;
 
 export interface AutoTitleFailure {
@@ -20,7 +17,9 @@ export interface AutoTitleFailure {
 export interface AutoTitleGeneration {
   systemPrompt: string;
   timeoutMs: number;
+  tokenBudget: number;
   thinkingLevel: ThinkingLevel | undefined;
+  persistRuns: boolean;
 }
 
 export type AutoTitleGenerationResult =
@@ -66,35 +65,47 @@ export async function generateAutoTitle(
   const abortController = new AbortController();
   const timeoutId = setTimeout(() => abortController.abort(), generation.timeoutMs);
   const thinkingLevel = generation.thinkingLevel;
+  const run = generation.persistRuns
+    ? startAutoTitleRun({
+        cwd: context.cwd ?? process.cwd(),
+        model,
+        trigger,
+        systemPrompt: resolvedSystemPrompt,
+        tokenBudget: generation.tokenBudget,
+        thinkingLevel,
+        message,
+      })
+    : undefined;
 
   try {
-    const requestContext = {
-      systemPrompt: resolvedSystemPrompt,
-      messages: [message],
-    };
-    writeAutoTitleDebugRequest(model, trigger, requestContext);
-    const response = await modelRuntime.completeSimple(model, requestContext, {
-      maxTokens: AUTO_TITLE_MAX_TOKENS,
-      ...(thinkingLevel && thinkingLevel !== "off" ? { reasoning: thinkingLevel } : {}),
-      signal: abortController.signal,
-    });
-    writeAutoTitleDebugResponse(model, trigger, response);
+    const response = await modelRuntime.completeSimple(
+      model,
+      {
+        systemPrompt: resolvedSystemPrompt,
+        messages: [message],
+      },
+      {
+        maxTokens: generation.tokenBudget,
+        ...(thinkingLevel && thinkingLevel !== "off" ? { reasoning: thinkingLevel } : {}),
+        signal: abortController.signal,
+      },
+    );
+    run?.recordResponse(response);
 
     if (response.stopReason === "error" || response.stopReason === "aborted") {
       const fallbackMessage =
         response.stopReason === "aborted" ? "Request was aborted." : "Provider returned an error.";
-      return {
-        ok: false,
-        failure: createAutoTitleFailure(trigger, model, response.errorMessage || fallbackMessage),
-      };
+      return failGeneration(run, trigger, model, response.errorMessage || fallbackMessage);
     }
 
     const normalizedTitle = normalizeGeneratedAutoTitle(extractResponseText(response.content));
     if (!normalizedTitle) {
-      return {
-        ok: false,
-        failure: createAutoTitleFailure(trigger, model, "Model returned an empty title."),
-      };
+      return failGeneration(
+        run,
+        trigger,
+        model,
+        describeEmptyTitle(response.stopReason === "length", generation.tokenBudget),
+      );
     }
 
     return {
@@ -102,10 +113,7 @@ export async function generateAutoTitle(
       title: normalizedTitle,
     };
   } catch (error) {
-    return {
-      ok: false,
-      failure: createAutoTitleFailure(trigger, model, extractErrorMessage(error)),
-    };
+    return failGeneration(run, trigger, model, extractErrorMessage(error));
   } finally {
     clearTimeout(timeoutId);
   }
@@ -124,6 +132,27 @@ export function createAutoTitleFailure(
   };
 }
 
+function failGeneration(
+  run: AutoTitleRun | undefined,
+  trigger: AutoTitleTrigger,
+  model: Model<Api>,
+  message: string,
+): AutoTitleGenerationResult {
+  run?.recordFailure(message);
+  return {
+    ok: false,
+    failure: createAutoTitleFailure(trigger, model, message),
+  };
+}
+
+function describeEmptyTitle(hitTokenBudget: boolean, tokenBudget: number): string {
+  if (!hitTokenBudget) {
+    return "Model returned an empty title.";
+  }
+
+  return `Model spent its ${tokenBudget}-token budget without producing a title. Raise sessions.autoTitle.tokenBudget if the model reasons before answering.`;
+}
+
 function buildAutoTitleSystemPrompt(systemPrompt: string, shouldPreserveTitle: boolean): string {
   if (!shouldPreserveTitle) {
     return systemPrompt;
@@ -170,45 +199,6 @@ function normalizeGeneratedAutoTitle(value: string): string | undefined {
   return truncated || undefined;
 }
 
-function writeAutoTitleDebugRequest(
-  model: Model<Api>,
-  trigger: AutoTitleTrigger,
-  request: unknown,
-): void {
-  writeAutoTitleDebugEntry({
-    phase: "request",
-    trigger,
-    model: formatModelLabel(model),
-    request,
-  });
-}
-
-function writeAutoTitleDebugResponse(
-  model: Model<Api>,
-  trigger: AutoTitleTrigger,
-  response: unknown,
-): void {
-  writeAutoTitleDebugEntry({
-    phase: "response",
-    trigger,
-    model: formatModelLabel(model),
-    response,
-  });
-}
-
-function writeAutoTitleDebugEntry(entry: Record<string, unknown>): void {
-  try {
-    const dir = join(homedir(), ".pi", "agent", "pi-sessions");
-    mkdirSync(dir, { recursive: true });
-    appendFileSync(
-      join(dir, "auto-title-debug.jsonl"),
-      `${JSON.stringify({ at: new Date().toISOString(), ...entry })}\n`,
-    );
-  } catch {
-    // Debug logging must not affect title generation.
-  }
-}
-
 function extractResponseText(content: unknown[]): string {
   return content
     .filter(

package/extensions/session-auto-title/install.ts

@@ -53,7 +53,9 @@ export function installAutoTitle(
   ): AutoTitleGeneration => ({
     systemPrompt: settings.autoTitle.prompt,
     timeoutMs: settings.autoTitle.timeoutMs,
+    tokenBudget: settings.autoTitle.tokenBudget,
     thinkingLevel: settings.autoTitle.thinkingLevel ?? resolution?.thinkingLevel,
+    persistRuns: settings.autoTitle.persistRuns,
   });
 
   pi.registerCommand("title", {

package/extensions/session-auto-title/runs.ts

@@ -0,0 +1,50 @@
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { Api, AssistantMessage, Model, UserMessage } from "@earendil-works/pi-ai";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { getDefaultAutoTitleRunsDir } from "../shared/settings.ts";
+import type { AutoTitleTrigger } from "./state.ts";
+
+export const AUTO_TITLE_RUN_REQUEST_CUSTOM_TYPE = "pi-sessions.auto-title-request";
+export const AUTO_TITLE_RUN_FAILURE_CUSTOM_TYPE = "pi-sessions.auto-title-failure";
+
+export interface AutoTitleRunRequest {
+  cwd: string;
+  model: Model<Api>;
+  trigger: AutoTitleTrigger;
+  systemPrompt: string;
+  tokenBudget: number;
+  thinkingLevel: ThinkingLevel | undefined;
+  message: UserMessage;
+}
+
+export interface AutoTitleRun {
+  sessionPath: string | undefined;
+  recordResponse(response: AssistantMessage): void;
+  recordFailure(message: string): void;
+}
+
+/** Records one auto-title request as a standalone Pi session so the exact prompt can be replayed. */
+export function startAutoTitleRun(request: AutoTitleRunRequest): AutoTitleRun {
+  const sessionManager = SessionManager.create(request.cwd, getDefaultAutoTitleRunsDir());
+  sessionManager.appendSessionInfo(`auto-title (${request.trigger})`);
+  sessionManager.appendModelChange(request.model.provider, request.model.id);
+  if (request.thinkingLevel) {
+    sessionManager.appendThinkingLevelChange(request.thinkingLevel);
+  }
+  sessionManager.appendCustomEntry(AUTO_TITLE_RUN_REQUEST_CUSTOM_TYPE, {
+    trigger: request.trigger,
+    systemPrompt: request.systemPrompt,
+    tokenBudget: request.tokenBudget,
+  });
+  sessionManager.appendMessage(request.message);
+
+  return {
+    sessionPath: sessionManager.getSessionFile(),
+    recordResponse(response) {
+      sessionManager.appendMessage(response);
+    },
+    recordFailure(message) {
+      sessionManager.appendCustomEntry(AUTO_TITLE_RUN_FAILURE_CUSTOM_TYPE, { message });
+    },
+  };
+}

package/extensions/session-handoff/board-view-model.ts

@@ -1,11 +1,9 @@
 import { tmuxSessionName } from "../shared/tmux.ts";
-import type { SubagentState } from "../subagents/classify.ts";
+import { isRunningSubagentState, type SubagentState } from "../subagents/classify.ts";
 import type { SubagentRosterEntry } from "../subagents/roster.ts";
 import { shellQuote } from "./launch/shell.ts";
 import type { HandoffLaunchReceipt } from "./receipt.ts";
 
-const RUNNING_SUBAGENT_STATES: ReadonlySet<SubagentState> = new Set(["starting", "busy", "active"]);
-
 export type HandoffBoardTab = "subagents" | "user-sessions";
 export type UserSessionStatus = "live" | "ready" | "starting" | "closed" | "unknown";
 
@@ -169,7 +167,7 @@ function buildUserSessionAction(
 function buildSubagentAction(entry: SubagentRosterEntry, insideTmux: boolean): HandoffBoardAction {
   return {
     subagent: entry,
-    canStop: RUNNING_SUBAGENT_STATES.has(entry.state),
+    canStop: isRunningSubagentState(entry.state),
     ...(entry.tmuxWindowId ? { observeCommand: buildObserveCommand(entry, insideTmux) } : {}),
     ...(!entry.managedLive ? { resumeCommand: entry.resumeCommand } : {}),
   };

package/extensions/session-handoff/bootstrap.ts

@@ -2,9 +2,9 @@ import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { SessionManager } from "@earendil-works/pi-coding-agent";
 import type { ModelRuntimeProvider } from "../shared/model-runtime.ts";
+import type { HandoffSettings } from "../shared/settings.ts";
 import { generateHandoffDraftFromSessionManager } from "./extract.ts";
 import { buildHandoffKickoffMessage, buildHandoffKickoffSource } from "./kickoff.ts";
-import { SUBAGENT_LAUNCH } from "./launch-target.ts";
 import {
   type ChildGeneratedHandoffBootstrap,
   createHandoffSessionMetadata,
@@ -23,8 +23,8 @@ export async function consumePendingHandoffBootstrap(
   pi: ExtensionAPI,
   ctx: ExtensionContext,
   getModelRuntime: ModelRuntimeProvider,
-  thinkingLevel: ThinkingLevel | undefined,
-  persistRuns: boolean,
+  destinationThinkingLevel: ThinkingLevel | undefined,
+  handoffSettings: HandoffSettings,
 ): Promise<void> {
   const scan = findPendingHandoffBootstrap(ctx.sessionManager.getBranch());
   if (!scan) {
@@ -56,8 +56,8 @@ export async function consumePendingHandoffBootstrap(
     scan.entryId,
     consumeBootstrap,
     getModelRuntime,
-    thinkingLevel,
-    persistRuns,
+    destinationThinkingLevel,
+    handoffSettings,
   );
 }
 
@@ -68,8 +68,8 @@ async function startChildGeneratedHandoff(
   bootstrapEntryId: string,
   consumeBootstrap: (reason: HandoffBootstrapConsumedReason) => void,
   getModelRuntime: ModelRuntimeProvider,
-  thinkingLevel: ThinkingLevel | undefined,
-  persistRuns: boolean,
+  destinationThinkingLevel: ThinkingLevel | undefined,
+  handoffSettings: HandoffSettings,
 ): Promise<void> {
   const entries = ctx.sessionManager.getEntries();
   if (hasStartedConversation(entries)) {
@@ -96,17 +96,17 @@ async function startChildGeneratedHandoff(
       ctx,
       "Generating handoff draft...",
       async (signal: AbortSignal) =>
-        generateHandoffDraftFromSessionManager(
+        generateHandoffDraftFromSessionManager({
           ctx,
           modelRuntime,
           sourceSessionManager,
-          bootstrap.sourceLeafId,
-          bootstrap.goal,
-          thinkingLevel,
-          persistRuns,
+          sourceLeafId: bootstrap.sourceLeafId,
+          goal: bootstrap.goal,
+          settings: handoffSettings,
+          destinationThinkingLevel,
           signal,
-          bootstrap.requestResponse,
-        ),
+          requestResponse: bootstrap.requestResponse,
+        }),
     );
     if (!generatedDraft) {
       consumeBootstrap("cancelled");
@@ -140,13 +140,11 @@ async function startChildGeneratedHandoff(
 
     // The tool-provided bootstrap title is authoritative; extraction does not
     // replace it with a second generated title.
-    const subagent = bootstrap.launch === SUBAGENT_LAUNCH ? bootstrap.subagent : undefined;
     const metadata = createHandoffSessionMetadata(
       bootstrap.goal,
       prompt,
       bootstrap.title,
       bootstrap.launch,
-      subagent,
     );
     if (!getHandoffMetadataFromEntries(ctx.sessionManager.getEntries())) {
       pi.appendEntry(HANDOFF_METADATA_CUSTOM_TYPE, metadata);

package/extensions/session-handoff/extract.ts

@@ -24,8 +24,9 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "typebox";
 import { freshenModel } from "../shared/model-runtime.ts";
-import { getDefaultHandoffRunsDir } from "../shared/settings.ts";
+import { getDefaultHandoffRunsDir, type HandoffSettings } from "../shared/settings.ts";
 import { parseTypeBoxValue } from "../shared/typebox.ts";
+import { resolveModelOverride } from "./model.ts";
 
 const MAX_HANDOFF_EXTRACTION_ATTEMPTS = 3;
 const HANDOFF_EXTRACTION_RETRY_PROMPT =
@@ -88,22 +89,39 @@ export function resolveHandoffSource(
   return sessionContext;
 }
 
-export async function generateHandoffDraftFromSessionManager(
-  ctx: ExtensionContext,
-  modelRuntime: ModelRuntime,
-  sourceSessionManager: ExtensionContext["sessionManager"],
-  sourceLeafId: string,
-  goal: string,
-  thinkingLevel: ThinkingLevel | undefined,
-  persistRuns: boolean,
-  signal?: AbortSignal,
+export async function generateHandoffDraftFromSessionManager({
+  ctx,
+  modelRuntime,
+  sourceSessionManager,
+  sourceLeafId,
+  goal,
+  settings,
+  destinationThinkingLevel,
+  signal,
   requestResponse = false,
-): Promise<HandoffDraftResult | undefined> {
-  if (!ctx.model) {
-    throw new Error("No model is available for handoff.");
+}: {
+  ctx: ExtensionContext;
+  modelRuntime: ModelRuntime;
+  sourceSessionManager: ExtensionContext["sessionManager"];
+  sourceLeafId: string;
+  goal: string;
+  settings: HandoffSettings;
+  destinationThinkingLevel: ThinkingLevel | undefined;
+  signal?: AbortSignal | undefined;
+  requestResponse?: boolean | undefined;
+}): Promise<HandoffDraftResult | undefined> {
+  const modelOverride = settings.model
+    ? resolveModelOverride(modelRuntime, settings.model, settings.thinkingLevel)
+    : undefined;
+  let model = modelOverride?.model;
+  if (!model) {
+    if (!ctx.model) {
+      throw new Error("No model is available for handoff.");
+    }
+    model = freshenModel(modelRuntime, ctx.model);
   }
-
-  const model = freshenModel(modelRuntime, ctx.model);
+  const thinkingLevel =
+    modelOverride?.thinkingLevel ?? settings.thinkingLevel ?? destinationThinkingLevel;
   const sessionContext = resolveHandoffSource(sourceSessionManager, sourceLeafId);
 
   const conversationText = serializeConversation(convertToLlm(sessionContext.messages));
@@ -114,7 +132,7 @@ export async function generateHandoffDraftFromSessionManager(
     conversationText,
     goal,
     thinkingLevel,
-    persistRuns,
+    settings.persistRuns,
     signal,
   );
   if (!handoffContext) {

package/extensions/session-handoff/install.ts

@@ -214,7 +214,7 @@ export function installHandoff(
         ctx,
         deps.getModelRuntime,
         pi.getThinkingLevel(),
-        settings.handoff.persistRuns,
+        settings.handoff,
       );
     },
   };

package/extensions/session-handoff/kickoff.ts

@@ -55,22 +55,23 @@ export function buildHandoffKickoffSource(source: HandoffKickoffSource): Handoff
   };
 }
 
-export const renderHandoffKickoffMessage: MessageRenderer = (message, _options, theme) => {
+export const renderHandoffKickoffMessage: MessageRenderer = (message, options, theme) => {
   const details = safeParseTypeBoxValue(HANDOFF_KICKOFF_DETAILS_SCHEMA, message.details);
   if (!details) {
     return undefined;
   }
 
   const prompt = typeof message.content === "string" ? message.content : "";
-  return createHandoffKickoffComponent(details, prompt, theme);
+  return createHandoffKickoffComponent(details, prompt, options.outputPad, theme);
 };
 
 export function createHandoffKickoffComponent(
   details: HandoffKickoffDetails,
   prompt: string,
+  outputPad: number,
   theme: RenderTheme,
 ): Component {
-  const box = new Box(1, 1, (text: string) => theme.bg("customMessageBg", text));
+  const box = new Box(outputPad, 1, (text: string) => theme.bg("customMessageBg", text));
   box.addChild(new Text(renderHandoffKickoffView(details, prompt, theme), 0, 0));
   return box;
 }

package/extensions/session-handoff/launch-target.ts

@@ -59,7 +59,7 @@ export interface HandoffLaunchTarget {
   description?: string | undefined;
   requestResponseDefault: boolean;
   bootstrapMode: "review" | "automatic";
-  /** Subagent launches stamp their child's identity into the durable handoff record. */
+  /** Subagent launches stamp their child's identity into the child bootstrap. */
   describeSubagentChild?(input: {
     childSessionId: string;
     ownerSessionId: string;

package/extensions/session-handoff/metadata.ts

@@ -3,6 +3,7 @@ import { type Static, Type } from "typebox";
 import { safeParseTypeBoxValue } from "../shared/typebox.ts";
 import { HANDOFF_KICKOFF_CUSTOM_TYPE, HANDOFF_KICKOFF_DETAILS_SCHEMA } from "./kickoff.ts";
 import {
+  HANDOFF_LAUNCH_VALUE_SCHEMA,
   HANDOFF_NON_SUBAGENT_LAUNCH_SCHEMA,
   type HandoffLaunchValue,
   SUBAGENT_LAUNCH,
@@ -16,7 +17,7 @@ export const HANDOFF_STALE_SESSION_MESSAGE =
 export const SESSION_STARTING_MESSAGE =
   "Target session is still starting. wait for it to show up in session_search, then resend.";
 
-// A subagent's self-knowledge, stamped into the durable handoff record so the
+// A subagent's self-knowledge, stamped into its child-local bootstrap so the
 // child never opens the parent transcript to learn who it is.
 export const HANDOFF_SUBAGENT_SCHEMA = Type.Object({
   childSessionId: Type.String(),
@@ -32,18 +33,10 @@ const HANDOFF_METADATA_BASE = {
   initial_prompt: Type.String(),
 };
 
-export const HANDOFF_SESSION_METADATA_SCHEMA = Type.Union([
-  Type.Object({
-    ...HANDOFF_METADATA_BASE,
-    launch: Type.Literal(SUBAGENT_LAUNCH),
-    subagent: HANDOFF_SUBAGENT_SCHEMA,
-  }),
-  Type.Object({
-    ...HANDOFF_METADATA_BASE,
-    launch: HANDOFF_NON_SUBAGENT_LAUNCH_SCHEMA,
-    subagent: Type.Optional(Type.Never()),
-  }),
-]);
+export const HANDOFF_SESSION_METADATA_SCHEMA = Type.Object({
+  ...HANDOFF_METADATA_BASE,
+  launch: HANDOFF_LAUNCH_VALUE_SCHEMA,
+});
 
 const HANDOFF_BOOTSTRAP_BASE = {
   mode: Type.Literal("generate"),
@@ -91,21 +84,14 @@ export function createHandoffSessionMetadata(
   initialPrompt: string,
   title: string,
   launch: HandoffLaunchValue,
-  subagent: HandoffSubagent | undefined,
 ): HandoffSessionMetadata {
-  const base = {
-    origin: "handoff" as const,
+  return {
+    origin: "handoff",
     goal: goal.trim(),
     title,
     initial_prompt: initialPrompt.trim(),
+    launch,
   };
-  if (launch === SUBAGENT_LAUNCH) {
-    if (!subagent) {
-      throw new Error("A subagent handoff requires a subagent identity block.");
-    }
-    return { ...base, launch, subagent };
-  }
-  return { ...base, launch };
 }
 
 export function createChildGeneratedHandoffBootstrap(options: {
@@ -195,6 +181,69 @@ export function isSessionStarting(branch: readonly SessionEntry[]): boolean {
   return findPendingHandoffBootstrap(branch)?.kind === "pending";
 }
 
+/**
+ * Folds the bootstrap lifecycle in one transcript pass. The bootstrap owns its
+ * data; kickoff and consumed entries only establish whether it started or ended.
+ */
+export function findCurrentHandoffBootstrap(
+  branch: readonly SessionEntry[],
+): HandoffBootstrap | undefined {
+  const bootstrapsById = new Map<string, HandoffBootstrap>();
+  const bootstrapIds: string[] = [];
+  const startedBootstrapIds: string[] = [];
+  const endedBootstrapIds = new Set<string>();
+  let conversationStarted = false;
+
+  for (const entry of branch) {
+    if (entry.type === "message" && entry.message.role === "user") {
+      conversationStarted = true;
+      continue;
+    }
+    if (entry.type === "custom_message" && entry.customType === HANDOFF_KICKOFF_CUSTOM_TYPE) {
+      conversationStarted = true;
+      const details = safeParseTypeBoxValue(HANDOFF_KICKOFF_DETAILS_SCHEMA, entry.details);
+      if (details?.bootstrapEntryId) {
+        startedBootstrapIds.push(details.bootstrapEntryId);
+      }
+      continue;
+    }
+    if (entry.type !== "custom") {
+      continue;
+    }
+    if (entry.customType === HANDOFF_BOOTSTRAP_PENDING_CUSTOM_TYPE) {
+      const bootstrap = safeParseTypeBoxValue(HANDOFF_BOOTSTRAP_SCHEMA, entry.data);
+      if (bootstrap) {
+        bootstrapsById.set(entry.id, bootstrap);
+        bootstrapIds.push(entry.id);
+      }
+      continue;
+    }
+    if (entry.customType === HANDOFF_BOOTSTRAP_CONSUMED_CUSTOM_TYPE) {
+      const consumed = safeParseTypeBoxValue(HANDOFF_BOOTSTRAP_CONSUMED_SCHEMA, entry.data);
+      if (consumed) {
+        endedBootstrapIds.add(consumed.bootstrapEntryId);
+      }
+    }
+  }
+
+  for (let index = startedBootstrapIds.length - 1; index >= 0; index -= 1) {
+    const bootstrap = bootstrapsById.get(startedBootstrapIds[index] ?? "");
+    if (bootstrap) {
+      return bootstrap;
+    }
+  }
+  if (conversationStarted) {
+    return undefined;
+  }
+  for (let index = bootstrapIds.length - 1; index >= 0; index -= 1) {
+    const bootstrapId = bootstrapIds[index];
+    if (bootstrapId && !endedBootstrapIds.has(bootstrapId)) {
+      return bootstrapsById.get(bootstrapId);
+    }
+  }
+  return undefined;
+}
+
 export function parseHandoffSessionMetadata(value: unknown): HandoffSessionMetadata | undefined {
   return safeParseTypeBoxValue(HANDOFF_SESSION_METADATA_SCHEMA, value);
 }