one-code-extension 0.4.0 → 0.5.0

package/extensions/tasks/index.ts

@@ -11,51 +11,134 @@
  *
  * The widget mirrors Claude Code's pinned task list (summary line + ✔/◼/◻
  * rows). Claude Code toggles it with ctrl+t, but pi reserves that key for
- * thinking blocks — `/tasks hide` / `/tasks show` covers it instead.
+ * thinking blocks, so alt+t (ctrl+\ on macOS; `taskToggleKey`) and `/tasks
+ * hide` / `/tasks show` toggle it here; the key's hint is always on screen.
  */
 
 import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { restoreLatestDetails } from "../lib/branch-restore.ts";
-import { DEFER_CHANNEL } from "../lib/deferred.ts";
+import { DEFER_CHANNEL, WITHHOLD_CHANNEL } from "../lib/deferred.ts";
+import { taskToolsEnabled } from "../lib/model-tier.ts";
+import { sessionModelTier } from "../lib/session-model-tier.ts";
 import { ccToolRenderers, linesComponent, safeThemeBold, safeThemePaint, strike } from "../lib/tui-render.ts";
 import { REMINDER_CHANNEL } from "../lib/reminders.ts";
-import { formatTaskDetails, formatTaskLine, formatTaskList, formatTaskWidget, nudgeMessage, type TaskSnapshot, TaskStore } from "./store.ts";
+import {
+	TASK_CREATE_DESCRIPTION,
+	TASK_CREATE_PARAMS,
+	TASK_GET_DESCRIPTION,
+	TASK_GET_PARAMS,
+	TASK_LIST_DESCRIPTION,
+	TASK_UPDATE_DESCRIPTION,
+	TASK_UPDATE_PARAMS,
+} from "./descriptions.ts";
+import {
+	FINISHED_LIST_CLEAR_MS,
+	formatHiddenTaskWidget,
+	formatTaskDetails,
+	formatTaskList,
+	formatTaskWidget,
+	normalizeTaskId,
+	nudgeMessage,
+	type TaskSnapshot,
+	TaskStore,
+} from "./store.ts";
 import { registerLocalCommand } from "../lib/local-command.ts";
+import { canShowCustomUi } from "../lib/headless-output.ts";
+import { taskToggleKey } from "../lib/keys.ts";
 
 interface TaskDetails {
 	taskSnapshot: TaskSnapshot;
 }
 
 const TASK_TOOLS = new Set(["task_create", "task_get", "task_list", "task_update"]);
+const TASK_KEYWORDS = ["task", "todo", "plan", "progress", "dependencies", "tracking"];
 
 export default function tasksExtension(pi: ExtensionAPI) {
+	const requestTier = sessionModelTier(pi);
 	const store = new TaskStore();
+	const toggleKey = taskToggleKey();
 	let widgetHidden = false;
 
 	const updateWidget = (ctx: ExtensionContext) => {
 		if (!ctx.hasUI) return;
-		if (widgetHidden || store.list().length === 0) {
+		if (store.list().length === 0) {
 			ctx.ui.setWidget("cc-tasks", undefined);
 			return;
 		}
+		// RPC forwards line arrays only, and has no terminal shortcut to hide it.
+		if (!canShowCustomUi(ctx)) {
+			ctx.ui.setWidget("cc-tasks", formatTaskWidget(store));
+			return;
+		}
 		// Component form so every line passes truncateLine — subjects are
 		// unbounded model text, and pi-tui crashes on an over-wide line.
 		ctx.ui.setWidget("cc-tasks", (_tui, theme) => {
 			const style = { paint: safeThemePaint(theme), bold: safeThemeBold(theme), strike };
-			return linesComponent(() => formatTaskWidget(store, 12, style));
+			return linesComponent(() =>
+				widgetHidden
+					? formatHiddenTaskWidget(store, `${toggleKey} to show`, style)
+					: formatTaskWidget(store, 12, style, `${toggleKey} to hide`),
+			);
 		});
 	};
+	const setWidgetHidden = (hidden: boolean, ctx: ExtensionContext) => {
+		widgetHidden = hidden;
+		updateWidget(ctx);
+	};
+
+	// Claude Code clears a finished list (every task completed) 5 s after it
+	// gets there, and the panel goes with it; reopening or adding a task first
+	// cancels the clear. Only where there is a widget: a one-shot run keeps its
+	// list. The timer is unref'd and cancelled on shutdown, so it never holds
+	// the process or fires into a disposed session.
+	let clearTimer: ReturnType<typeof setTimeout> | undefined;
+	const cancelClear = () => {
+		if (clearTimer) clearTimeout(clearTimer);
+		clearTimer = undefined;
+	};
+	const scheduleClear = (ctx: ExtensionContext) => {
+		if (!ctx.hasUI || !store.isFinished()) return cancelClear();
+		if (clearTimer) return;
+		clearTimer = setTimeout(() => {
+			clearTimer = undefined;
+			if (!store.isFinished()) return;
+			store.clear();
+			updateWidget(ctx);
+		}, FINISHED_LIST_CLEAR_MS);
+		clearTimer.unref?.();
+	};
 
 	const reconstructState = (ctx: ExtensionContext) => {
+		cancelClear();
 		const details = restoreLatestDetails<TaskDetails>(ctx.sessionManager.getBranch(), TASK_TOOLS, (d) => Boolean(d?.taskSnapshot));
 		store.restore(details?.taskSnapshot);
 		updateWidget(ctx);
 	};
 
-	pi.on("session_start", (_event, ctx) => reconstructState(ctx));
+	// Claude Code's model gate: frontier models and Sonnet 5+ run without the
+	// task tools unless CLAUDE_CODE_ENABLE_TODO_TOOLS is set (lib/model-tier.ts
+	// taskToolsEnabled). Re-applied on a model change, so switching to a model
+	// that has them brings them back through the deferred listing.
+	let withheld = false;
+	const applyModelGate = (model: Parameters<typeof taskToolsEnabled>[0]) => {
+		const enabled = taskToolsEnabled(model, process.env, requestTier());
+		if (enabled === !withheld) return;
+		withheld = !enabled;
+		for (const name of TASK_TOOLS) {
+			if (withheld) pi.events.emit(WITHHOLD_CHANNEL, { name });
+			else pi.events.emit(DEFER_CHANNEL, { name, keywords: TASK_KEYWORDS });
+		}
+	};
+
+	pi.on("session_start", (_event, ctx) => {
+		reconstructState(ctx);
+		applyModelGate(ctx.model);
+	});
 	pi.on("session_tree", (_event, ctx) => reconstructState(ctx));
+	pi.on("model_select", (event) => applyModelGate(event.model));
+	pi.on("session_shutdown", () => cancelClear());
 
 	// Claude Code's periodic task_reminder (TODO_REMINDER_CONFIG): a gentle
 	// nudge once the task tools have gone unused for TURNS_SINCE_WRITE turns,
@@ -71,6 +154,8 @@ export default function tasksExtension(pi: ExtensionAPI) {
 	let turnsSinceReminder = TURNS_BETWEEN_REMINDERS;
 
 	pi.on("turn_end", () => {
+		// Claude Code's reminder needs TaskUpdate in the tool list.
+		if (withheld) return;
 		turnsSinceTaskUse++;
 		turnsSinceReminder++;
 		if (turnsSinceTaskUse < TURNS_SINCE_WRITE || turnsSinceReminder < TURNS_BETWEEN_REMINDERS) return;
@@ -86,6 +171,7 @@ export default function tasksExtension(pi: ExtensionAPI) {
 
 	const result = (text: string, ctx: ExtensionContext, isError = false) => {
 		updateWidget(ctx);
+		scheduleClear(ctx);
 		return {
 			content: [{ type: "text" as const, text }],
 			details: { taskSnapshot: store.snapshot() } satisfies TaskDetails,
@@ -97,18 +183,17 @@ export default function tasksExtension(pi: ExtensionAPI) {
 		name: "task_create",
 		label: "Create Task",
 		...ccToolRenderers("Create Task"),
-		description:
-			"Add a task to the session's structured task list. Tasks are addressable by id and can carry owners, metadata, and dependencies — use task_update to change status or link tasks, task_list/task_get to read them. Create tasks for multi-step work (3+ steps) so progress is visible, and mark exactly one in_progress while working on it.",
+		description: TASK_CREATE_DESCRIPTION,
 		parameters: Type.Object({
-			subject: Type.String({ description: "A brief title for the task" }),
-			description: Type.String({ description: "What needs to be done" }),
-			activeForm: Type.Optional(Type.String({ description: 'Present continuous form shown while in_progress (e.g. "Running tests")' })),
-			metadata: Type.Optional(Type.Record(Type.String(), Type.Unknown(), { description: "Arbitrary metadata to attach to the task" })),
+			subject: Type.String({ description: TASK_CREATE_PARAMS.subject }),
+			description: Type.String({ description: TASK_CREATE_PARAMS.description }),
+			activeForm: Type.Optional(Type.String({ description: TASK_CREATE_PARAMS.activeForm })),
+			metadata: Type.Optional(Type.Record(Type.String(), Type.Unknown(), { description: TASK_CREATE_PARAMS.metadata })),
 		}),
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
 			markUsed();
 			const task = store.create(params);
-			return result(`Created task #${task.id}: ${task.subject}`, ctx);
+			return result(`Task #${task.id} created successfully: ${task.subject}`, ctx);
 		},
 	});
 
@@ -116,9 +201,9 @@ export default function tasksExtension(pi: ExtensionAPI) {
 		name: "task_get",
 		label: "Get Task",
 		...ccToolRenderers("Get Task"),
-		description: "Retrieve one task by id: full description, status, owner, and dependency links. Verify blockedBy is empty before starting work on it.",
+		description: TASK_GET_DESCRIPTION,
 		parameters: Type.Object({
-			taskId: Type.String({ description: "The id of the task to retrieve" }),
+			taskId: Type.String({ description: TASK_GET_PARAMS.taskId }),
 		}),
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
 			const task = store.get(params.taskId);
@@ -131,7 +216,7 @@ export default function tasksExtension(pi: ExtensionAPI) {
 		name: "task_list",
 		label: "List Tasks",
 		...ccToolRenderers("List Tasks", { maxCollapsedLines: 12 }),
-		description: "List all tasks: id, subject, status, owner, and open blockers. Prefer working on unblocked pending tasks in id order.",
+		description: TASK_LIST_DESCRIPTION,
 		parameters: Type.Object({}),
 		async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
 			return result(formatTaskList(store), ctx);
@@ -142,49 +227,43 @@ export default function tasksExtension(pi: ExtensionAPI) {
 		name: "task_update",
 		label: "Update Task",
 		...ccToolRenderers("Update Task"),
-		description:
-			"Update a task: status (pending/in_progress/completed, or deleted to remove it), subject, description, owner, metadata (merge; null deletes a key), and dependencies via addBlocks/addBlockedBy. Mark a task in_progress before starting it and completed only when fully done.",
+		description: TASK_UPDATE_DESCRIPTION,
 		parameters: Type.Object({
-			taskId: Type.String({ description: "The id of the task to update" }),
-			status: Type.Optional(StringEnum(["pending", "in_progress", "completed", "deleted"] as const)),
-			subject: Type.Optional(Type.String()),
-			description: Type.Optional(Type.String()),
-			activeForm: Type.Optional(Type.String()),
-			owner: Type.Optional(Type.String({ description: "New owner for the task" })),
-			metadata: Type.Optional(Type.Record(Type.String(), Type.Unknown(), { description: "Metadata keys to merge; a null value deletes the key" })),
-			addBlocks: Type.Optional(Type.Array(Type.String(), { description: "Task ids that cannot start until this one completes" })),
-			addBlockedBy: Type.Optional(Type.Array(Type.String(), { description: "Task ids that must complete before this one" })),
+			taskId: Type.String({ description: TASK_UPDATE_PARAMS.taskId }),
+			subject: Type.Optional(Type.String({ description: TASK_UPDATE_PARAMS.subject })),
+			description: Type.Optional(Type.String({ description: TASK_UPDATE_PARAMS.description })),
+			activeForm: Type.Optional(Type.String({ description: TASK_UPDATE_PARAMS.activeForm })),
+			status: Type.Optional(StringEnum(["pending", "in_progress", "completed", "deleted"] as const, { description: TASK_UPDATE_PARAMS.status })),
+			addBlocks: Type.Optional(Type.Array(Type.String(), { description: TASK_UPDATE_PARAMS.addBlocks })),
+			addBlockedBy: Type.Optional(Type.Array(Type.String(), { description: TASK_UPDATE_PARAMS.addBlockedBy })),
+			owner: Type.Optional(Type.String({ description: TASK_UPDATE_PARAMS.owner })),
+			metadata: Type.Optional(Type.Record(Type.String(), Type.Unknown(), { description: TASK_UPDATE_PARAMS.metadata })),
 		}),
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
 			const { taskId, ...input } = params;
 			const outcome = store.update(taskId, input as Parameters<TaskStore["update"]>[1]);
 			if (outcome.deleted) {
 				markUsed();
-				return result(`Deleted task #${taskId}.`, ctx);
+				return result(`Updated task #${normalizeTaskId(taskId)} deleted`, ctx);
 			}
 			// A failed update (unknown id) is not "using" the tracker — a model
 			// looping on a hallucinated id must not suppress the nudge.
 			if (outcome.error && !outcome.task) return result(outcome.error, ctx, true);
 			markUsed();
-			const line = formatTaskLine(store, outcome.task!);
+			// Claude Code's result names the fields that changed.
+			const line = `Updated task #${outcome.task!.id} ${(outcome.updatedFields ?? []).join(", ")}`;
 			return result(outcome.error ? `${line}\n${outcome.error}` : line, ctx, Boolean(outcome.error));
 		},
 	});
 
 	for (const name of TASK_TOOLS) {
-		pi.events.emit(DEFER_CHANNEL, { name, keywords: ["task", "todo", "plan", "progress", "dependencies", "tracking"] });
+		pi.events.emit(DEFER_CHANNEL, { name, keywords: TASK_KEYWORDS });
 	}
 
-	registerLocalCommand(pi, "tasks", {
-		description: "Show the structured task list; 'hide'/'show' toggles the widget",
-		handler: async (args, ctx) => {
-			const arg = args?.trim().toLowerCase();
-			if (arg === "hide" || arg === "show") {
-				widgetHidden = arg === "hide";
-				updateWidget(ctx);
-				return;
-			}
-			ctx.ui.notify(formatTaskList(store), "info");
-		},
+	// `/tasks` is Claude Code's Background dialog (the subagents extension, findings
+	// §40); the task list toggles with its key only, as Claude Code's does.
+	pi.registerShortcut(toggleKey, {
+		description: "Show or hide the task list",
+		handler: (ctx) => setWidgetHidden(!widgetHidden, ctx),
 	});
 }

package/extensions/tasks/store.ts

@@ -38,6 +38,11 @@ export interface TaskUpdateInput {
 	addBlockedBy?: string[];
 }
 
+/** A task id as the model may write it: tasks show as `#3`, so a leading `#` names task 3. */
+export function normalizeTaskId(id: string): string {
+	return id.startsWith("#") ? id.slice(1) : id;
+}
+
 export class TaskStore {
 	private tasks = new Map<string, TaskItem>();
 	private nextId = 1;
@@ -58,7 +63,7 @@ export class TaskStore {
 	}
 
 	get(id: string): TaskItem | undefined {
-		return this.tasks.get(id);
+		return this.tasks.get(normalizeTaskId(id));
 	}
 
 	list(): TaskItem[] {
@@ -73,9 +78,14 @@ export class TaskStore {
 		});
 	}
 
-	update(id: string, input: TaskUpdateInput): { task?: TaskItem; deleted?: boolean; error?: string } {
+	/**
+	 * Apply an update. `updatedFields` names what actually changed, in Claude
+	 * Code's order (its TaskUpdate result lists them).
+	 */
+	update(rawId: string, input: TaskUpdateInput): { task?: TaskItem; deleted?: boolean; error?: string; updatedFields?: string[] } {
+		const id = normalizeTaskId(rawId);
 		const task = this.tasks.get(id);
-		if (!task) return { error: `No task with id "${id}". Use task_list to see ids.` };
+		if (!task) return { error: `No task with id "${rawId}". Use task_list to see ids.` };
 
 		if (input.status === "deleted") {
 			this.tasks.delete(id);
@@ -86,17 +96,33 @@ export class TaskStore {
 			return { deleted: true };
 		}
 
-		if (input.subject !== undefined) task.subject = input.subject;
-		if (input.description !== undefined) task.description = input.description;
-		if (input.activeForm !== undefined) task.activeForm = input.activeForm;
-		if (input.status !== undefined) task.status = input.status;
-		if (input.owner !== undefined) task.owner = input.owner || undefined;
-
+		const updatedFields: string[] = [];
+		if (input.subject !== undefined && input.subject !== task.subject) {
+			task.subject = input.subject;
+			updatedFields.push("subject");
+		}
+		if (input.description !== undefined && input.description !== task.description) {
+			task.description = input.description;
+			updatedFields.push("description");
+		}
+		if (input.activeForm !== undefined && input.activeForm !== task.activeForm) {
+			task.activeForm = input.activeForm;
+			updatedFields.push("activeForm");
+		}
+		if (input.owner !== undefined && (input.owner || undefined) !== task.owner) {
+			task.owner = input.owner || undefined;
+			updatedFields.push("owner");
+		}
 		if (input.metadata) {
 			for (const [key, value] of Object.entries(input.metadata)) {
 				if (value === null) delete task.metadata[key];
 				else task.metadata[key] = value;
 			}
+			updatedFields.push("metadata");
+		}
+		if (input.status !== undefined && input.status !== task.status) {
+			task.status = input.status;
+			updatedFields.push("status");
 		}
 
 		// Separate a self-reference from a genuinely unknown id: link() rejects
@@ -104,19 +130,23 @@ export class TaskStore {
 		// task id" — sending the model to hunt a typo that isn't there.
 		const unknown: string[] = [];
 		let selfRef = false;
-		for (const other of input.addBlocks ?? []) {
+		const blocksBefore = task.blocks.length;
+		for (const other of (input.addBlocks ?? []).map(normalizeTaskId)) {
 			if (other === id) selfRef = true;
 			else if (!this.link(id, other)) unknown.push(other);
 		}
-		for (const other of input.addBlockedBy ?? []) {
+		if (task.blocks.length > blocksBefore) updatedFields.push("blocks");
+		const blockedByBefore = task.blockedBy.length;
+		for (const other of (input.addBlockedBy ?? []).map(normalizeTaskId)) {
 			if (other === id) selfRef = true;
 			else if (!this.link(other, id)) unknown.push(other);
 		}
+		if (task.blockedBy.length > blockedByBefore) updatedFields.push("blockedBy");
 		const errors: string[] = [];
 		if (selfRef) errors.push(`Task #${id} cannot block or be blocked by itself`);
 		if (unknown.length > 0) errors.push(`Unknown task id(s) in dependency list: ${unknown.join(", ")}`);
-		if (errors.length > 0) return { task, error: errors.join(". ") };
-		return { task };
+		if (errors.length > 0) return { task, error: errors.join(". "), updatedFields };
+		return { task, updatedFields };
 	}
 
 	/** Record "blocker blocks blocked" on both sides. False if either id is unknown. */
@@ -133,15 +163,42 @@ export class TaskStore {
 		return { nextId: this.nextId, tasks: this.list().map((t) => ({ ...t, metadata: { ...t.metadata }, blocks: [...t.blocks], blockedBy: [...t.blockedBy] })) };
 	}
 
+	/**
+	 * A non-empty list with every task completed: the state Claude Code clears
+	 * itself from, 5 s after it is reached (`FINISHED_LIST_CLEAR_MS`).
+	 */
+	isFinished(): boolean {
+		const tasks = this.list();
+		return tasks.length > 0 && tasks.every((t) => t.status === "completed");
+	}
+
+	/**
+	 * Drop every task and keep the id counter, as Claude Code's reset does (it
+	 * records the high-water mark before deleting), so a task created after a
+	 * clear never reuses an id the transcript already mentions.
+	 */
+	clear(): void {
+		this.tasks.clear();
+	}
+
+	/**
+	 * A finished snapshot restores as empty: the clear runs on a timer and never
+	 * lands in a tool result, so without this rule `/resume` or a `/tree` switch
+	 * would bring back a list Claude Code would already have cleared.
+	 */
 	restore(snapshot: TaskSnapshot | undefined): void {
 		this.tasks.clear();
 		this.nextId = snapshot?.nextId ?? 1;
 		for (const task of snapshot?.tasks ?? []) {
 			this.tasks.set(task.id, { ...task, metadata: { ...task.metadata }, blocks: [...task.blocks], blockedBy: [...task.blockedBy] });
 		}
+		if (this.isFinished()) this.clear();
 	}
 }
 
+/** How long a finished list stays on screen before it clears (Claude Code's 5000 ms). */
+export const FINISHED_LIST_CLEAR_MS = 5_000;
+
 const STATUS_MARK: Record<TaskStatus, string> = { pending: " ", in_progress: "▸", completed: "x" };
 
 export function formatTaskLine(store: TaskStore, task: TaskItem): string {
@@ -193,7 +250,7 @@ function taskRow(task: TaskItem, { paint, bold, strike }: WidgetStyle): string {
  * past `maxTasks` so the widget cannot swallow the screen (Claude Code's
  * cutoff is unverified).
  */
-export function formatTaskWidget(store: TaskStore, maxTasks = 12, style: WidgetStyle = PLAIN_STYLE): string[] {
+export function formatTaskWidget(store: TaskStore, maxTasks = 12, style: WidgetStyle = PLAIN_STYLE, hint?: string): string[] {
 	const { paint, bold } = style;
 	const tasks = store.list();
 	if (tasks.length === 0) return [];
@@ -203,13 +260,23 @@ export function formatTaskWidget(store: TaskStore, maxTasks = 12, style: WidgetS
 	const dim = (text: string) => paint("dim", text);
 	const count = (n: number) => bold(dim(String(n)));
 	const lines = [
-		`  ${count(tasks.length)}${dim(` ${tasks.length === 1 ? "task" : "tasks"} (`)}${count(done)}${dim(" done, ")}${count(inProgress)}${dim(" in progress, ")}${count(open)}${dim(" open)")}`,
+		`  ${count(tasks.length)}${dim(` ${tasks.length === 1 ? "task" : "tasks"} (`)}${count(done)}${dim(" done, ")}${count(inProgress)}${dim(" in progress, ")}${count(open)}${dim(" open)")}${hint ? dim(` · ${hint}`) : ""}`,
 	];
 	for (const t of tasks.slice(0, maxTasks)) lines.push(`  ${taskRow(t, style)}`);
 	if (tasks.length > maxTasks) lines.push(`  ${dim(`… +${tasks.length - maxTasks} more`)}`);
 	return lines;
 }
 
+/**
+ * The one line left when the user hides the list, so the key that brings it
+ * back stays on screen (Claude Code shows "ctrl+t to show tasks" in its footer).
+ */
+export function formatHiddenTaskWidget(store: TaskStore, hint: string, style: WidgetStyle = PLAIN_STYLE): string[] {
+	const n = store.list().length;
+	if (n === 0) return [];
+	return [`  ${style.paint("dim", `${n} ${n === 1 ? "task" : "tasks"} hidden · ${hint}`)}`];
+}
+
 /**
  * The periodic task-tool reminder (Claude Code's `task_reminder`): a single
  * gentle nudge fired when the task tools have gone unused for a while, with the
@@ -217,7 +284,7 @@ export function formatTaskWidget(store: TaskStore, maxTasks = 12, style: WidgetS
  * when the user pivots mid-session and the plan no longer matches the work.
  *
  * Byte-for-byte Claude Code's text (messages.ts) except the tool names, which
- * stay our snake_case (docs/decisions/tools.md). We do NOT branch on list state
+ * stay our snake_case (working-docs/decisions/tools.md). We do NOT branch on list state
  * the way CC's earlier prompt did — one reminder, always the same, and the
  * appended list is what the model reasons over.
  */

package/extensions/tool-call-corruption/child.ts

@@ -0,0 +1,7 @@
+/** The OpenRouter stream guard for an in-process child session (lib/child-extensions.ts): blocks and stops, prints nothing. */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { toolCallCorruptionGuard } from "./index.ts";
+
+export default function childToolCallCorruptionExtension(pi: ExtensionAPI) {
+	toolCallCorruptionGuard(pi, { announce: false });
+}