pi-voicekit 0.2.1 → 0.2.3

package/README.md

@@ -399,6 +399,10 @@ Every dictation also writes one `voice-polish` entry into the session file: the
 transcript, what reached the editor and why the pass decided that. The model never sees
 these entries — they are not part of the conversation context — so they are there for
 analysis, and they do keep the raw text on disk for as long as the session file exists.
+Each entry also records how the pass was configured: the transcript length on its own
+(separate from any text already in the editor), whether thinking was turned off for it,
+and the output-token cap it carried, plus the audio seconds it covered and which recogniser
+produced it — which is what makes polish time readable as a speedup.
 
 | Setting                   | Scope              | Default     | Notes                                                   |
 | ------------------------- | ------------------ | ----------- | ------------------------------------------------------- |

package/extensions/voice/post-process-prompt.ts

@@ -69,7 +69,10 @@ If nothing in <TRANSCRIPT> can be cleaned, return it unchanged.
  */
 export function polishMaxTokens(rawChars: number): number {
 	const bounded = Number.isFinite(rawChars) ? Math.max(1, Math.floor(rawChars)) : 1;
-	return Math.min(4096, Math.max(1024, Math.ceil(bounded * 2) + 512));
+	// The floor is 2048 because thinking is not bounded by the input length: a 76-character
+	// dictation spent about 1,200 reasoning tokens, so the earlier 1024 floor truncated it and
+	// dropped the pass back to the raw transcript after a 7.6 s wait.
+	return Math.min(4096, Math.max(2048, Math.ceil(bounded * 2) + 512));
 }
 
 function renderContext(context: AssembledContext): string {

package/extensions/voice/post-process.ts

@@ -240,6 +240,18 @@ export interface PolishAudit {
 	latencyMs?: number;
 	contextChars?: number;
 	truncated?: boolean;
+	/** Characters of the dictation itself, excluding text already in the editor. */
+	transcriptChars?: number;
+	/** Characters of the editor prefix, which is not part of the transcript. */
+	editorPrefixChars?: number;
+	/** Seconds of audio the dictation covered, so polish time can be read as a speedup. */
+	durationSec?: number;
+	/** Which recogniser produced it, so results are never pooled across backends. */
+	backend?: string;
+	/** True when the pass asked the model not to think. */
+	thinkingOff?: boolean;
+	/** The output-token cap the request carried, a cap and not a spend. */
+	maxTokens?: number;
 }
 
 export function buildPolishAudit(input: {
@@ -248,6 +260,12 @@ export function buildPolishAudit(input: {
 	status?: string;
 	disposition?: string;
 	reason?: string;
+	transcriptChars?: number;
+	editorPrefixChars?: number;
+	thinkingOff?: boolean;
+	durationSec?: number;
+	backend?: string;
+	maxTokens?: number;
 	telemetry?: {
 		model?: string;
 		configured?: string;
@@ -266,6 +284,12 @@ export function buildPolishAudit(input: {
 	if (input.status !== undefined) audit.status = input.status;
 	if (input.disposition !== undefined) audit.disposition = input.disposition;
 	if (input.reason !== undefined) audit.reason = input.reason;
+	if (input.transcriptChars !== undefined) audit.transcriptChars = input.transcriptChars;
+	if (input.editorPrefixChars !== undefined) audit.editorPrefixChars = input.editorPrefixChars;
+	if (input.thinkingOff !== undefined) audit.thinkingOff = input.thinkingOff;
+	if (input.maxTokens !== undefined) audit.maxTokens = input.maxTokens;
+	if (input.durationSec !== undefined) audit.durationSec = input.durationSec;
+	if (input.backend !== undefined) audit.backend = input.backend;
 	const telemetry = input.telemetry;
 	if (telemetry) {
 		if (telemetry.model !== undefined) audit.model = telemetry.model;

package/extensions/voice.ts

@@ -114,6 +114,7 @@ import {
 	resolveModelChoice,
 } from "./voice/post-process";
 import { DEFAULT_CONTEXT_LIMITS } from "./voice/post-process-context";
+import { polishMaxTokens } from "./voice/post-process-prompt";
 
 /** Adapter for the real event loop — lets GapTimer run under the real setTimeout. */
 const realTimerPort: TimerPort = {
@@ -883,6 +884,9 @@ export default function (pi: ExtensionAPI) {
 		ms: number;
 		contextChars?: number;
 		truncated?: boolean;
+		/** Recorded so a slow or truncated pass can be diagnosed without reading code. */
+		thinkingOff?: boolean;
+		maxTokens?: number;
 		reason?: string;
 		error?: string;
 	};
@@ -987,6 +991,10 @@ export default function (pi: ExtensionAPI) {
 			const telemetry = {
 				model: polishModelLabel(choice),
 				configured: choice.ref,
+				// Pure and cheap, so computing it twice (here and in the call options) is fine, and it
+				// keeps the audit entry honest about what the pass decided.
+				thinkingOff: Boolean(polishSamplingOptions(model as { reasoning?: boolean }, raw.length).samplingParams),
+				maxTokens: polishMaxTokens(raw.length),
 				status: result.status,
 				ms: Date.now() - started,
 				contextChars: result.contextChars,
@@ -1818,6 +1826,12 @@ export default function (pi: ExtensionAPI) {
 								"voice-polish",
 								buildPolishAudit({
 									raw: prefix + fullText,
+									transcriptChars: fullText.length,
+									editorPrefixChars: prefix.length,
+									thinkingOff: polishTelemetry?.thinkingOff,
+									maxTokens: polishTelemetry?.maxTokens,
+									durationSec: Number(elapsed),
+									backend: config.backend,
 									written: wroteEditor ? finalText : undefined,
 									status: final.status,
 									disposition: final.disposition,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-voicekit",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Voice in + voice out for Pi CLI — hold-to-talk STT (Deepgram streaming or 21 offline models) plus TTS (Kitten Nano, Piper, Kokoro, or Deepgram Aura)",
   "type": "module",
   "keywords": [