pi-ui-extend 0.1.13 → 0.1.17

package/dist/app/types.d.ts

@@ -5,7 +5,7 @@ import type { ThemeName } from "../theme.js";
 import type { ToastKind, ToastNotifier } from "../ui.js";
 import type { RenderedLink } from "./screen/file-links.js";
 import type { WorkspaceMutation } from "./workspace/workspace-undo.js";
-import type { SUBAGENT_ACTIVE_STATUSES, SUBAGENT_RENDER_MODES, SUBAGENT_STATUSES, SUBAGENT_TERMINAL_STATUSES, THINKING_LEVELS, TODO_ACTIONS, TODO_PRIORITIES, TODO_STATUSES } from "./constants.js";
+import type { SUBAGENT_ACTIVE_STATUSES, SUBAGENT_RENDER_MODES, SUBAGENT_STATUSES, SUBAGENT_TERMINAL_STATUSES, THINKING_LEVELS, TODO_ACTIONS, TODO_STATUSES } from "./constants.js";
 export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
 export type NativeModifierKey = "shift" | "command" | "control" | "option";
 export type SessionActivity = "idle" | "running" | "thinking";
@@ -92,23 +92,22 @@ export type Entry = {
 };
 export type TodoAction = (typeof TODO_ACTIONS)[number];
 export type TodoStatus = (typeof TODO_STATUSES)[number];
-export type TodoPriority = (typeof TODO_PRIORITIES)[number];
 export type TodoTask = {
     id: number;
     subject: string;
     status: TodoStatus;
     description?: string;
     activeForm?: string;
-    priority?: TodoPriority;
+    thinking?: ThinkingLevel;
     parentId?: number;
     blockedBy?: number[];
-    tags?: string[];
     owner?: string;
     metadata?: Record<string, unknown>;
 };
 export type TodoTaskLinePart = {
     text: string;
     muted?: boolean;
+    thinking?: ThinkingLevel;
 };
 export type TodoTaskRow = {
     task: TodoTask;
@@ -261,6 +260,7 @@ export type StatusLineLayout = {
     text: string;
     sessionLabel: string;
     workspaceLabel: string;
+    inputBorderWidgetStartColumn?: number;
     modelUsageLabel?: string;
     contextBarLabel?: string;
     userJumpWidget?: StatusUserJumpWidgetLayout;
@@ -379,6 +379,14 @@ export type PixMenuItem<T = string> = {
     label: string;
     description?: string;
     keywords?: readonly string[];
+    labelHighlightRanges?: readonly {
+        start: number;
+        end: number;
+    }[];
+    descriptionHighlightRanges?: readonly {
+        start: number;
+        end: number;
+    }[];
     variant?: PixMenuVariant;
 };
 export type PixMenuOptions = {
@@ -386,6 +394,8 @@ export type PixMenuOptions = {
     placeholder?: string;
     emptyText?: string;
     searchable?: boolean;
+    minScorePerCharacter?: number;
+    preferKeyboardLayoutMatches?: boolean;
     preserveStatus?: boolean;
 };
 export type PixMenuSelectOptions = Omit<PixMenuOptions, "title">;
@@ -498,9 +508,10 @@ export type ThinkingMenuValue = {
     level: ThinkingLevel;
     current: boolean;
 };
-export type UserMessageMenuValue = "copy" | "fork" | "undo";
+export type UserMessageMenuValue = "copy" | "fork" | "fork-new-tab" | "undo";
 export type UserMessageJumpMenuValue = {
-    entryId: string;
+    entryId?: string;
+    sessionEntryId?: string;
 };
 export type QueueMessageMenuValue = "cancel" | "edit" | "send-now";
 export type ResumeMenuValue = {

package/dist/app/workspace/workspace-actions-controller.d.ts

@@ -18,6 +18,7 @@ export type AppWorkspaceActionsControllerHost = {
     showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
     render(): void;
     isRunning(): boolean;
+    forkSessionEntryInNewTab(sessionEntryId: string): Promise<boolean>;
 };
 export declare class AppWorkspaceActionsController {
     private readonly host;
@@ -30,6 +31,7 @@ export declare class AppWorkspaceActionsController {
     syncUserSessionEntryMetadata(): void;
     copyUserMessage(entryId: string): Promise<void>;
     forkFromUserMessage(entryId: string): Promise<void>;
+    forkFromUserMessageInNewTab(entryId: string): Promise<void>;
     undoChangesFromUserMessage(entryId: string): Promise<void>;
     private resolveUserSessionEntryId;
     private getIdleRuntimeForAction;

package/dist/app/workspace/workspace-actions-controller.js

@@ -108,6 +108,18 @@ export class AppWorkspaceActionsController {
         this.host.setSessionStatus(runtime.session);
         this.host.showToast("Session forked", "success");
     }
+    async forkFromUserMessageInNewTab(entryId) {
+        const runtime = this.getIdleRuntimeForAction("fork in new tab");
+        if (!runtime)
+            return;
+        const entry = this.host.findUserEntry(entryId);
+        if (!entry)
+            throw new Error("User message is no longer available");
+        const sessionEntryId = this.resolveUserSessionEntryId(entry);
+        if (!sessionEntryId)
+            throw new Error("Session entry for this message is not available yet");
+        await this.host.forkSessionEntryInNewTab(sessionEntryId);
+    }
     async undoChangesFromUserMessage(entryId) {
         const runtime = this.getIdleRuntimeForAction("undo changes");
         if (!runtime)

package/dist/config.d.ts

@@ -67,16 +67,21 @@ export type PixConfig = {
     modelColors: ModelColorsConfig;
     iconTheme: IconThemeConfig;
     dictation: DictationConfig;
+    ignoreContextFiles: boolean;
+    maxProjectSessions: number;
 };
 export declare function getPixConfigPath(homeDir?: string): string;
+export declare function getProjectPixConfigPath(cwd: string): string;
 export declare function resolveDefaultModelRef(config: PixConfig): string | undefined;
 export declare function savePixDefaultModel(modelRef: string): DefaultModelConfig | undefined;
 export declare function savePixDefaultThinking(thinking: string, fallbackModelRef?: string): DefaultModelConfig | undefined;
 export declare function savePixAutocompleteModel(modelRef: string): AutocompleteConfig;
+export declare function saveProjectPixIgnoreContextFiles(cwd: string, ignoreContextFiles: boolean): boolean;
+export declare function upsertPixIgnoreContextFilesInJsonc(source: string, ignoreContextFiles: boolean): string;
 export declare function upsertPixDefaultModelInJsonc(source: string, modelRef: string): string;
 export declare function upsertPixDefaultThinkingInJsonc(source: string, thinking: string, fallbackModelRef?: string): string;
 export declare function upsertPixAutocompleteModelInJsonc(source: string, modelRef: string): string;
-export declare function loadPixConfig(): PixConfig;
+export declare function loadPixConfig(cwd?: string): PixConfig;
 export declare function savePixDictationLanguage(language: string): void;
 export declare function upsertPixDictationLanguageInJsonc(source: string, language: string): string;
 export declare function resolveModelColor(modelRef: string, config: ModelColorsConfig): string | undefined;

package/dist/config.js

@@ -4,9 +4,13 @@ import { homedir } from "node:os";
 import { applyEdits, modify, parse } from "jsonc-parser";
 import { appIconThemeFromFallbackFlag, appIconThemeOverrideFromEnv, parseAppIconThemeName, resolveAppIconThemeNameFromEnv, } from "./app/icons.js";
 import { DEFAULT_PIX_CONFIG_JSONC } from "./default-pix-config.js";
+const PIX_SCHEMA_URL = "https://unpkg.com/pi-ui-extend/schemas/pix.json";
 export function getPixConfigPath(homeDir = homedir()) {
     return join(homeDir, ".config", "pi", "pix.jsonc");
 }
+export function getProjectPixConfigPath(cwd) {
+    return join(cwd, ".pi", "pix.jsonc");
+}
 const PIX_CONFIG_PATH = getPixConfigPath();
 const DEFAULT_TOOL_RENDERER = {
     default: {
@@ -68,9 +72,6 @@ const DEFAULT_MODEL_COLORS = {
         "antigravity/antigravity-claude-*": "error",
     },
 };
-const DEFAULT_ICON_THEME = {
-    name: "nerdFont",
-};
 const DEFAULT_DICTATION = {
     language: "en",
     languages: {
@@ -164,17 +165,21 @@ function extractDefaultModelConfig(raw) {
         return undefined;
     const configured = raw.defaultModel ?? raw.modelDefault;
     if (typeof configured === "string") {
-        const modelRef = configured.trim();
-        return modelRef ? { modelRef } : undefined;
+        return normalizeDefaultModelRef(configured);
     }
     if (!isPlainObject(configured))
         return undefined;
     const modelRef = nonEmptyString(configured.modelRef) ?? nonEmptyString(configured.model);
     if (!modelRef)
         return undefined;
-    const thinking = normalizeThinkingLevel(configured.thinking) ?? normalizeThinkingLevel(configured.thinkingLevel);
+    const normalizedModel = normalizeDefaultModelRef(modelRef);
+    if (!normalizedModel)
+        return undefined;
+    const thinking = normalizeDefaultThinking(configured.thinking)
+        ?? normalizeDefaultThinking(configured.thinkingLevel)
+        ?? normalizedModel.thinking;
     return {
-        modelRef,
+        modelRef: normalizedModel.modelRef,
         ...(thinking === undefined ? {} : { thinking }),
     };
 }
@@ -241,6 +246,18 @@ function extractDictationConfig(raw) {
         languages,
     } : undefined;
 }
+function extractIgnoreContextFiles(raw) {
+    if (!isPlainObject(raw))
+        return undefined;
+    return typeof raw.ignoreContextFiles === "boolean" ? raw.ignoreContextFiles : undefined;
+}
+function extractMaxProjectSessions(raw) {
+    if (!isPlainObject(raw))
+        return undefined;
+    if (typeof raw.maxProjectSessions !== "number" || !Number.isFinite(raw.maxProjectSessions))
+        return undefined;
+    return Math.max(0, Math.floor(raw.maxProjectSessions));
+}
 function normalizeDictationLanguage(value) {
     if (typeof value !== "string")
         return undefined;
@@ -253,6 +270,9 @@ function normalizeThinkingLevel(value) {
     const normalized = value.trim().toLowerCase();
     return THINKING_LEVELS.includes(normalized) ? normalized : undefined;
 }
+function normalizeDefaultThinking(value) {
+    return normalizeThinkingLevel(value);
+}
 function nonEmptyString(value) {
     if (typeof value !== "string")
         return undefined;
@@ -274,15 +294,31 @@ function defaultPixConfig() {
         modelColors: DEFAULT_MODEL_COLORS,
         iconTheme: { name: resolveAppIconThemeNameFromEnv() },
         dictation: DEFAULT_DICTATION,
+        ignoreContextFiles: false,
+        maxProjectSessions: 0,
     };
 }
+function pixConfigFromParsed(parsed, fallback = defaultPixConfig()) {
+    const toolRenderer = extractToolRendererConfig(parsed) ?? fallback.toolRenderer;
+    const outputFilters = extractOutputFiltersConfig(parsed) ?? fallback.outputFilters;
+    const defaultModel = extractDefaultModelConfig(parsed) ?? fallback.defaultModel;
+    const promptEnhancer = extractPromptEnhancerConfig(parsed) ?? fallback.promptEnhancer;
+    const autocomplete = extractAutocompleteConfig(parsed) ?? fallback.autocomplete;
+    const modelColors = extractModelColorsConfig(parsed) ?? fallback.modelColors;
+    const configuredIconTheme = extractIconThemeConfig(parsed) ?? fallback.iconTheme;
+    const iconTheme = { name: appIconThemeOverrideFromEnv() ?? configuredIconTheme.name };
+    const dictation = extractDictationConfig(parsed) ?? fallback.dictation;
+    const ignoreContextFiles = extractIgnoreContextFiles(parsed) ?? fallback.ignoreContextFiles;
+    const maxProjectSessions = extractMaxProjectSessions(parsed) ?? fallback.maxProjectSessions;
+    return { toolRenderer, outputFilters, ...(defaultModel === undefined ? {} : { defaultModel }), promptEnhancer, autocomplete, modelColors, iconTheme, dictation, ignoreContextFiles, maxProjectSessions };
+}
 export function resolveDefaultModelRef(config) {
     const modelRef = config.defaultModel?.modelRef.trim();
     if (!modelRef)
         return undefined;
     const thinking = config.defaultModel?.thinking;
     if (!thinking)
-        return modelRef;
+        return stripThinkingSuffix(modelRef);
     return `${stripThinkingSuffix(modelRef)}:${thinking}`;
 }
 export function savePixDefaultModel(modelRef) {
@@ -297,7 +333,7 @@ export function savePixDefaultModel(modelRef) {
     return extractDefaultModelConfig(parseJsonc(updated));
 }
 export function savePixDefaultThinking(thinking, fallbackModelRef) {
-    const normalizedThinking = normalizeThinkingLevel(thinking);
+    const normalizedThinking = normalizeDefaultThinking(thinking);
     if (!normalizedThinking)
         return undefined;
     const configPath = PIX_CONFIG_PATH;
@@ -318,6 +354,21 @@ export function savePixAutocompleteModel(modelRef) {
     writeFileSync(configPath, updated);
     return extractAutocompleteConfig(parseJsonc(updated)) ?? { ...DEFAULT_AUTOCOMPLETE, modelRef: modelRef.trim() };
 }
+export function saveProjectPixIgnoreContextFiles(cwd, ignoreContextFiles) {
+    const configPath = getProjectPixConfigPath(cwd);
+    const source = existsSync(configPath) ? readFileSync(configPath, "utf8") : `{
+  "$schema": "${PIX_SCHEMA_URL}"
+}
+`;
+    const updated = upsertPixIgnoreContextFilesInJsonc(source, ignoreContextFiles);
+    mkdirSync(dirname(configPath), { recursive: true });
+    writeFileSync(configPath, updated);
+    return extractIgnoreContextFiles(parseJsonc(updated)) ?? ignoreContextFiles;
+}
+export function upsertPixIgnoreContextFilesInJsonc(source, ignoreContextFiles) {
+    const formattingOptions = { insertSpaces: true, tabSize: 2 };
+    return applyEdits(source, modify(source, ["ignoreContextFiles"], ignoreContextFiles, { formattingOptions }));
+}
 export function upsertPixDefaultModelInJsonc(source, modelRef) {
     const normalized = normalizeDefaultModelRef(modelRef);
     if (!normalized)
@@ -332,7 +383,7 @@ export function upsertPixDefaultModelInJsonc(source, modelRef) {
     return upsertPixDefaultModelObjectInJsonc(source, parsed, next);
 }
 export function upsertPixDefaultThinkingInJsonc(source, thinking, fallbackModelRef) {
-    const normalizedThinking = normalizeThinkingLevel(thinking);
+    const normalizedThinking = normalizeDefaultThinking(thinking);
     if (!normalizedThinking)
         return source;
     const parsed = parseJsonc(source);
@@ -370,7 +421,7 @@ function normalizeDefaultModelRef(modelRef) {
     if (colonIndex <= 0)
         return { modelRef: trimmed };
     const suffix = trimmed.slice(colonIndex + 1);
-    const thinking = normalizeThinkingLevel(suffix);
+    const thinking = normalizeDefaultThinking(suffix);
     return thinking ? { modelRef: trimmed.slice(0, colonIndex), thinking } : { modelRef: trimmed };
 }
 function stripThinkingSuffix(modelRef) {
@@ -378,7 +429,7 @@ function stripThinkingSuffix(modelRef) {
     if (colonIndex <= 0)
         return modelRef;
     const suffix = modelRef.slice(colonIndex + 1);
-    return normalizeThinkingLevel(suffix) ? modelRef.slice(0, colonIndex) : modelRef;
+    return normalizeDefaultThinking(suffix) ? modelRef.slice(0, colonIndex) : modelRef;
 }
 function extractToolRendererRule(value) {
     if (!isPlainObject(value))
@@ -415,32 +466,38 @@ function ensurePixConfigExists(configPath) {
         throw error;
     }
 }
-export function loadPixConfig() {
+export function loadPixConfig(cwd) {
     const configPath = PIX_CONFIG_PATH;
     try {
         ensurePixConfigExists(configPath);
     }
     catch (error) {
         process.stderr.write(`[pix] Failed to create ${configPath}: ${error instanceof Error ? error.message : String(error)}\n`);
-        return defaultPixConfig();
+        return loadProjectPixConfig(cwd, defaultPixConfig());
     }
     try {
         const raw = readFileSync(configPath, "utf8");
         const parsed = parseJsonc(raw);
-        const toolRenderer = extractToolRendererConfig(parsed) ?? DEFAULT_TOOL_RENDERER;
-        const outputFilters = extractOutputFiltersConfig(parsed) ?? DEFAULT_OUTPUT_FILTERS;
-        const defaultModel = extractDefaultModelConfig(parsed);
-        const promptEnhancer = extractPromptEnhancerConfig(parsed) ?? DEFAULT_PROMPT_ENHANCER;
-        const autocomplete = extractAutocompleteConfig(parsed) ?? DEFAULT_AUTOCOMPLETE;
-        const modelColors = extractModelColorsConfig(parsed) ?? DEFAULT_MODEL_COLORS;
-        const configuredIconTheme = extractIconThemeConfig(parsed) ?? DEFAULT_ICON_THEME;
-        const iconTheme = { name: appIconThemeOverrideFromEnv() ?? configuredIconTheme.name };
-        const dictation = extractDictationConfig(parsed) ?? DEFAULT_DICTATION;
-        return { toolRenderer, outputFilters, ...(defaultModel === undefined ? {} : { defaultModel }), promptEnhancer, autocomplete, modelColors, iconTheme, dictation };
+        return loadProjectPixConfig(cwd, pixConfigFromParsed(parsed));
+    }
+    catch (error) {
+        process.stderr.write(`[pix] Failed to load ${configPath}: ${error instanceof Error ? error.message : String(error)}\n`);
+        return loadProjectPixConfig(cwd, defaultPixConfig());
+    }
+}
+function loadProjectPixConfig(cwd, fallback) {
+    if (!cwd)
+        return fallback;
+    const configPath = getProjectPixConfigPath(cwd);
+    if (!existsSync(configPath))
+        return fallback;
+    try {
+        const raw = readFileSync(configPath, "utf8");
+        return pixConfigFromParsed(parseJsonc(raw), fallback);
     }
     catch (error) {
         process.stderr.write(`[pix] Failed to load ${configPath}: ${error instanceof Error ? error.message : String(error)}\n`);
-        return defaultPixConfig();
+        return fallback;
     }
 }
 export function savePixDictationLanguage(language) {

package/dist/default-pix-config.js

@@ -2,6 +2,10 @@ export const DEFAULT_PIX_CONFIG_JSONC = String.raw `{
   "$schema": "https://unpkg.com/pi-ui-extend/schemas/pix.json",
   // pix renderer configuration
   "defaultModel": { "modelRef": "openai-codex/gpt-5.5", "thinking": "medium" },
+  // Disable AGENTS.md / CLAUDE.md discovery for this project when set in <cwd>/.pi/pix.jsonc.
+  "ignoreContextFiles": false,
+  // Maximum pi session JSONL files to retain per project. 0 disables automatic deletion.
+  "maxProjectSessions": 0,
 
   "toolRenderer": {
     "default": { "previewLines": 0, "direction": "head", "color": "toolTitle" },

package/dist/fuzzy.d.ts

@@ -19,5 +19,7 @@ export type FuzzyMatch<T> = {
 export type FuzzySearchOptions = {
     limit?: number;
     includeEmptyQuery?: boolean;
+    minScorePerCharacter?: number;
+    preferKeyboardLayoutMatches?: boolean;
 };
 export declare function fuzzySearch<T>(items: readonly FuzzySearchItem<T>[], query: string, options?: FuzzySearchOptions): FuzzyMatch<T>[];

package/dist/fuzzy.js

@@ -41,7 +41,7 @@ export function fuzzySearch(items, query, options = {}) {
     const includeEmptyQuery = options.includeEmptyQuery ?? true;
     if (!includeEmptyQuery && normalizedQuery.length === 0)
         return [];
-    const matches = [];
+    const candidateMatches = [];
     items.forEach((item, rank) => {
         const texts = [item.label, ...(item.aliases ?? []), ...(item.keywords ?? [])];
         let best;
@@ -51,21 +51,28 @@ export function fuzzySearch(items, query, options = {}) {
                 if (!score)
                     continue;
                 const adjustedScore = score.score - queryVariant.penalty;
-                if (!best || adjustedScore > best.score)
-                    best = { ...score, score: adjustedScore, text };
+                if (!best || adjustedScore > best.score) {
+                    best = { ...score, score: adjustedScore, text, keyboardLayout: queryVariant.keyboardLayout };
+                }
             }
         }
         if (!best)
             return;
-        matches.push({
+        if (isBelowMinimumScore(best.score, normalizedQuery, options.minScorePerCharacter))
+            return;
+        candidateMatches.push({
             value: item.value,
             label: item.label,
             matchedText: best.text,
             matchedRanges: best.ranges,
             score: best.score,
             rank,
+            keyboardLayout: best.keyboardLayout,
         });
     });
+    const matches = options.preferKeyboardLayoutMatches && shouldPreferKeyboardLayoutMatches(query) && candidateMatches.some((match) => match.keyboardLayout)
+        ? candidateMatches.filter((match) => match.keyboardLayout)
+        : candidateMatches;
     matches.sort((left, right) => {
         const scoreDelta = right.score - left.score;
         if (scoreDelta !== 0)
@@ -75,7 +82,12 @@ export function fuzzySearch(items, query, options = {}) {
             return rankDelta;
         return left.label.localeCompare(right.label);
     });
-    return options.limit === undefined ? matches : matches.slice(0, options.limit);
+    return (options.limit === undefined ? matches : matches.slice(0, options.limit)).map(({ keyboardLayout: _keyboardLayout, ...match }) => match);
+}
+function isBelowMinimumScore(score, normalizedQuery, minScorePerCharacter) {
+    if (minScorePerCharacter === undefined || normalizedQuery.length === 0)
+        return false;
+    return score < normalizedQuery.length * minScorePerCharacter;
 }
 function scoreFuzzyMatch(normalizedQuery, text) {
     if (normalizedQuery.length === 0) {
@@ -149,7 +161,7 @@ function normalizeText(value) {
     return value.toLowerCase();
 }
 function getQueryVariants(normalizedQuery) {
-    const variants = [{ query: normalizedQuery, penalty: 0 }];
+    const variants = [{ query: normalizedQuery, penalty: 0, keyboardLayout: false }];
     addKeyboardLayoutVariant(variants, normalizedQuery, RUSSIAN_TO_ENGLISH_KEYBOARD_LAYOUT);
     addKeyboardLayoutVariant(variants, normalizedQuery, ENGLISH_TO_RUSSIAN_KEYBOARD_LAYOUT);
     return variants;
@@ -158,7 +170,15 @@ function addKeyboardLayoutVariant(variants, normalizedQuery, layout) {
     const variant = remapKeyboardLayout(normalizedQuery, layout);
     if (variant === normalizedQuery || variants.some((existing) => existing.query === variant))
         return;
-    variants.push({ query: variant, penalty: KEYBOARD_LAYOUT_VARIANT_PENALTY });
+    variants.push({ query: variant, penalty: KEYBOARD_LAYOUT_VARIANT_PENALTY, keyboardLayout: true });
+}
+function shouldPreferKeyboardLayoutMatches(query) {
+    const trimmed = query.trim();
+    if (!trimmed)
+        return false;
+    if (/^[А-ЯЁ][а-яё]+$/u.test(trimmed))
+        return false;
+    return /[А-ЯЁ]/u.test(trimmed);
 }
 function remapKeyboardLayout(value, layout) {
     return Array.from(value, (char) => layout[char] ?? char).join("");

package/dist/input-editor.d.ts

@@ -49,6 +49,11 @@ export interface VisualLine {
         end: number;
     }>;
 }
+export interface InputEditorDraftState {
+    text: string;
+    cursor: number;
+    attachments?: readonly Attachment[];
+}
 /** Full render-ready snapshot of the editor state. */
 export interface RenderedEditor {
     visualLines: VisualLine[];
@@ -70,6 +75,7 @@ export declare class InputEditor {
     private readonly _redoStack;
     private _historyMutationDepth;
     private _restoringHistory;
+    private _contentVersion;
     get text(): string;
     get cursor(): number;
     get selection(): Selection | undefined;
@@ -78,6 +84,8 @@ export declare class InputEditor {
     get hasAttachments(): boolean;
     get canUndo(): boolean;
     get canRedo(): boolean;
+    get contentVersion(): number;
+    get draftState(): InputEditorDraftState;
     /** Get only image attachments. */
     get images(): ImageContent[];
     /** Get the text to submit — virtual attachment tags are expanded or removed. */
@@ -91,6 +99,7 @@ export declare class InputEditor {
      */
     get promptText(): string;
     setText(text: string, cursor?: number): void;
+    setDraftState(state: InputEditorDraftState): void;
     clear(): void;
     undo(): boolean;
     redo(): boolean;

package/dist/input-editor.js

@@ -27,6 +27,7 @@ export class InputEditor {
     _redoStack = [];
     _historyMutationDepth = 0;
     _restoringHistory = false;
+    _contentVersion = 0;
     // ── public getters ──────────────────────────────────────────────
     get text() { return this._text; }
     get cursor() { return this._cursor; }
@@ -38,6 +39,14 @@ export class InputEditor {
     get hasAttachments() { return this._attachments.length > 0; }
     get canUndo() { return this._undoStack.length > 0; }
     get canRedo() { return this._redoStack.length > 0; }
+    get contentVersion() { return this._contentVersion; }
+    get draftState() {
+        return {
+            text: this._text,
+            cursor: this._cursor,
+            ...(this._attachments.length > 0 ? { attachments: this._attachments.map(cloneAttachment) } : {}),
+        };
+    }
     /** Get only image attachments. */
     get images() {
         const images = [];
@@ -93,7 +102,20 @@ export class InputEditor {
             this.clearSelection();
         });
     }
+    setDraftState(state) {
+        this.recordEdit(() => {
+            this._text = state.text;
+            this._cursor = state.cursor;
+            this._attachments.length = 0;
+            this._attachments.push(...Array.from(state.attachments ?? [], cloneAttachment));
+            this._imageCounter = Math.max(this._imageCounter, maxTagCounter(this._attachments, /^\[Image (\d+)/u));
+            this._pasteCounter = Math.max(this._pasteCounter, maxTagCounter(this._attachments, /^\[Pasted ~?(\d+)/u));
+            this.clampCursor();
+            this.clearSelection();
+        });
+    }
     clear() {
+        const hadContent = this._text.length > 0 || this._attachments.length > 0;
         this._text = "";
         this._cursor = 0;
         this.clearSelection();
@@ -102,6 +124,8 @@ export class InputEditor {
         this._imageCounter = 0;
         this._pasteCounter = 0;
         this.clearHistory();
+        if (hadContent)
+            this._contentVersion += 1;
     }
     undo() {
         const previous = this._undoStack.pop();
@@ -115,6 +139,7 @@ export class InputEditor {
             this._redoStack.length = 0;
         }
         this.restoreHistorySnapshot(previous);
+        this._contentVersion += 1;
         this.trimHistory();
         return true;
     }
@@ -130,6 +155,7 @@ export class InputEditor {
             this._undoStack.length = 0;
         }
         this.restoreHistorySnapshot(next);
+        this._contentVersion += 1;
         this.trimHistory();
         return true;
     }
@@ -545,6 +571,7 @@ export class InputEditor {
         }
         if (!this.didContentChangeFrom(before))
             return;
+        this._contentVersion += 1;
         this.clearScrollOffset();
         if (!this.isRecordableHistorySnapshot(before)) {
             this.clearHistory();
@@ -867,6 +894,31 @@ function removeVirtualAttachmentTag(text, tag) {
         return text.replace(withTrailingSpace, "");
     return text.replace(tag, "");
 }
+function cloneAttachment(attachment) {
+    if (attachment.kind === "image") {
+        return { kind: "image", tag: attachment.tag, image: { ...attachment.image } };
+    }
+    if (attachment.kind === "pasted-text") {
+        return { kind: "pasted-text", tag: attachment.tag, text: attachment.text, lineCount: attachment.lineCount };
+    }
+    return {
+        kind: "file",
+        tag: attachment.tag,
+        path: attachment.path,
+        ...(attachment.content === undefined ? {} : { content: attachment.content }),
+        ...(attachment.image === undefined ? {} : { image: { ...attachment.image } }),
+    };
+}
+function maxTagCounter(attachments, pattern) {
+    let max = 0;
+    for (const attachment of attachments) {
+        const match = pattern.exec(attachment.tag);
+        const value = match ? Number.parseInt(match[1] ?? "", 10) : NaN;
+        if (Number.isFinite(value))
+            max = Math.max(max, value);
+    }
+    return max;
+}
 function suggestionSpansForChunk(chunkStart, chunkEnd, suggestionStart, suggestionEnd, prefixLength) {
     const start = Math.max(chunkStart, suggestionStart);
     const end = Math.min(chunkEnd, suggestionEnd);

package/dist/schemas/pi-tools-suite-schema.d.ts

@@ -9,6 +9,7 @@ export declare const PiToolsSuiteConfigSchema: Type.TObject<{
     $schema: Type.TOptional<Type.TString>;
     enabled: Type.TOptional<Type.TBoolean>;
     disabledModules: Type.TOptional<Type.TArray<Type.TString>>;
+    todoThinking: Type.TOptional<Type.TBoolean>;
     terminalBell: Type.TOptional<Type.TObject<{
         sound: Type.TOptional<Type.TBoolean>;
     }>>;

package/dist/schemas/pi-tools-suite-schema.js

@@ -203,6 +203,7 @@ export const PiToolsSuiteConfigSchema = Type.Object({
     $schema: Type.Optional(Type.String({ description: "JSON Schema URL used by editors for validation and autocomplete." })),
     enabled: Type.Optional(Type.Boolean({ description: "Enable or disable the entire pi-tools-suite extension." })),
     disabledModules: Type.Optional(Type.Array(Type.String(), { description: "List of disabled module names (e.g. ['lsp', 'prompt-commands'])." })),
+    todoThinking: Type.Optional(Type.Boolean({ description: "Enable per-todo thinking levels and automatic thinking switch/restore when tasks become in-progress/completed." })),
     terminalBell: Type.Optional(TerminalBellConfig),
     dcp: Type.Optional(DcpConfig),
     asyncSubagents: Type.Optional(AsyncSubagentsConfig),

package/dist/schemas/pix-schema.d.ts

@@ -1,5 +1,5 @@
 /**
- * TypeBox JSON Schema definitions for pix.jsonc (~/.config/pi/pix.jsonc).
+ * TypeBox JSON Schema definitions for pix.jsonc (~/.config/pi/pix.jsonc or <cwd>/.pi/pix.jsonc).
  *
  * These schemas describe the _user-facing_ config shape — all fields are optional
  * because the runtime applies generous defaults.  The generated JSON Schema files
@@ -8,6 +8,8 @@
 import { Type, Static } from "typebox";
 export declare const PixConfigSchema: Type.TObject<{
     $schema: Type.TOptional<Type.TString>;
+    ignoreContextFiles: Type.TOptional<Type.TBoolean>;
+    maxProjectSessions: Type.TOptional<Type.TNumber>;
     defaultModel: Type.TOptional<Type.TObject<{
         modelRef: Type.TOptional<Type.TString>;
         thinking: Type.TOptional<Type.TUnion<Type.TLiteral<string>[]>>;