gsd-pi 2.77.0-dev.538325aea → 2.77.0-dev.58d3d4d6c

package/dist/resources/extensions/gsd/worktree-resolver.js

@@ -17,6 +17,9 @@ import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { debugLog } from "./debug-logger.js";
 import { emitJournalEvent } from "./journal.js";
+import { emitWorktreeCreated, emitWorktreeMerged } from "./worktree-telemetry.js";
+import { getCollapseCadence, getMilestoneResquash, resquashMilestoneOnMain } from "./slice-cadence.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
 // ─── Path Helpers ──────────────────────────────────────────────────────────
 /**
  * Worktree marker segment — present in any path produced by worktreePath().
@@ -194,6 +197,20 @@ export class WorktreeResolver {
                 eventType: "worktree-enter",
                 data: { milestoneId, wtPath, created: !existingPath },
             });
+            // #4764 — record creation/enter as a lifecycle event so the telemetry
+            // aggregator can pair it with the eventual worktree-merged event.
+            try {
+                emitWorktreeCreated(this.s.originalBasePath || this.s.basePath, milestoneId, {
+                    reason: existingPath ? "enter-milestone" : "create-milestone",
+                });
+            }
+            catch (telemetryErr) {
+                debugLog("WorktreeResolver", {
+                    action: "enterMilestone",
+                    phase: "telemetry-emit",
+                    error: telemetryErr instanceof Error ? telemetryErr.message : String(telemetryErr),
+                });
+            }
             ctx.notify(`Entered worktree for ${milestoneId} at ${wtPath}`, "info");
         }
         catch (err) {
@@ -289,6 +306,9 @@ export class WorktreeResolver {
      */
     mergeAndExit(milestoneId, ctx) {
         this.validateMilestoneId(milestoneId);
+        // #4764 — telemetry: record start timestamp so we can emit merge duration.
+        const mergeStartedAt = new Date().toISOString();
+        const mergeStartMs = Date.now();
         // If worktree creation failed earlier, skip merge — work is on current branch (#2483)
         if (this.s.isolationDegraded) {
             debugLog("WorktreeResolver", {
@@ -328,14 +348,68 @@ export class WorktreeResolver {
             });
             return;
         }
+        let actuallyMerged = false;
         if (mode === "worktree" || inWorktree) {
-            this._mergeWorktreeMode(milestoneId, ctx);
+            actuallyMerged = this._mergeWorktreeMode(milestoneId, ctx);
         }
         else if (mode === "branch") {
-            this._mergeBranchMode(milestoneId, ctx);
+            actuallyMerged = this._mergeBranchMode(milestoneId, ctx);
+        }
+        // The remainder of this function emits telemetry and runs re-squash.
+        // Both are gated on actuallyMerged — if the _merge* helper took a
+        // no-merge path (missing originalBase, no roadmap, wrong branch) the
+        // milestone branch was intentionally left unmerged and we must not
+        // emit a worktree-merged event or collapse commits on main.
+        if (!actuallyMerged) {
+            // Always clear the start-SHA tracker to avoid leaking across sessions.
+            this.s.milestoneStartShas.delete(milestoneId);
+            return;
+        }
+        // #4765 — when collapse_cadence=slice AND milestone_resquash=true, the
+        // N per-slice commits on main should be collapsed into one milestone
+        // commit. Done AFTER the primary merge-and-teardown so the branch and
+        // worktree are already cleaned up; we operate on main directly.
+        try {
+            const startSha = this.s.milestoneStartShas.get(milestoneId);
+            if (startSha) {
+                const prefs = loadEffectiveGSDPreferences(this.s.originalBasePath || this.s.basePath)?.preferences;
+                if (getCollapseCadence(prefs) === "slice" && getMilestoneResquash(prefs)) {
+                    const result = resquashMilestoneOnMain(this.s.originalBasePath || this.s.basePath, milestoneId, startSha);
+                    if (result.resquashed) {
+                        ctx.notify(`slice-cadence: re-squashed slice commits for ${milestoneId} into a single milestone commit.`, "info");
+                    }
+                }
+                this.s.milestoneStartShas.delete(milestoneId);
+            }
+        }
+        catch (err) {
+            debugLog("WorktreeResolver", {
+                action: "mergeAndExit",
+                milestoneId,
+                phase: "resquash",
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        // #4764 — record merge completion. Only reaches here when an actual
+        // merge ran; failure paths throw out of _merge* before this point and
+        // no-merge paths returned above.
+        try {
+            emitWorktreeMerged(this.s.originalBasePath || this.s.basePath, milestoneId, {
+                reason: "milestone-complete",
+                startedAt: mergeStartedAt,
+                durationMs: Date.now() - mergeStartMs,
+            });
+        }
+        catch (telemetryErr) {
+            debugLog("WorktreeResolver", {
+                action: "mergeAndExit",
+                phase: "telemetry-emit",
+                error: telemetryErr instanceof Error ? telemetryErr.message : String(telemetryErr),
+            });
         }
     }
-    /** Worktree-mode merge: read roadmap, merge, teardown, reset paths. */
+    /** Worktree-mode merge: read roadmap, merge, teardown, reset paths.
+     *  Returns true when a squash-merge actually ran (false on skip paths). */
     _mergeWorktreeMode(milestoneId, ctx) {
         const originalBase = this.s.originalBasePath;
         if (!originalBase) {
@@ -346,8 +420,9 @@ export class WorktreeResolver {
                 skipped: true,
                 reason: "missing-original-base",
             });
-            return;
+            return false;
         }
+        let merged = false;
         try {
             const { synced } = this.deps.syncWorktreeStateBack(originalBase, this.s.basePath, milestoneId);
             if (synced.length > 0) {
@@ -378,6 +453,7 @@ export class WorktreeResolver {
             if (roadmapPath) {
                 const roadmapContent = this.deps.readFileSync(roadmapPath, "utf-8");
                 const mergeResult = this.deps.mergeMilestoneToMain(originalBase, milestoneId, roadmapContent);
+                merged = true;
                 // #2945 Bug 3: mergeMilestoneToMain performs best-effort worktree
                 // cleanup internally (step 12), but it can silently fail on Windows
                 // or when the worktree directory is locked. Perform a secondary
@@ -470,8 +546,10 @@ export class WorktreeResolver {
             result: "done",
             basePath: this.s.basePath,
         });
+        return merged;
     }
-    /** Branch-mode merge: check current branch, merge if on milestone branch. */
+    /** Branch-mode merge: check current branch, merge if on milestone branch.
+     *  Returns true when a merge actually ran (false on skip paths). */
     _mergeBranchMode(milestoneId, ctx) {
         try {
             const currentBranch = this.deps.getCurrentBranch(this.s.basePath);
@@ -486,7 +564,7 @@ export class WorktreeResolver {
                     currentBranch,
                     milestoneBranch,
                 });
-                return;
+                return false;
             }
             const roadmapPath = this.deps.resolveMilestoneFile(this.s.basePath, milestoneId, "ROADMAP");
             if (!roadmapPath) {
@@ -497,7 +575,7 @@ export class WorktreeResolver {
                     skipped: true,
                     reason: "no-roadmap",
                 });
-                return;
+                return false;
             }
             const roadmapContent = this.deps.readFileSync(roadmapPath, "utf-8");
             const mergeResult = this.deps.mergeMilestoneToMain(this.s.basePath, milestoneId, roadmapContent);
@@ -516,6 +594,7 @@ export class WorktreeResolver {
                 mode: "branch",
                 result: "success",
             });
+            return true;
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);

package/dist/resources/extensions/gsd/worktree-telemetry.js

@@ -0,0 +1,198 @@
+/**
+ * Worktree telemetry — #4764
+ *
+ * Thin emit helpers + aggregator on top of the existing journal. Separate
+ * module so callers import a tiny surface and don't have to assemble
+ * JournalEntry records by hand. Kernighan: the underlying emit path
+ * (emitJournalEvent) is already battle-tested; this module is just
+ * structured call sites + a summarizer.
+ *
+ * Emitted event types (see journal.ts):
+ *   - worktree-created           worktree entered/created for a milestone
+ *   - worktree-merged            worktree merge back to main completed
+ *   - worktree-orphaned          audit detected an orphaned branch/worktree
+ *   - auto-exit                  auto-mode exited (pause/stop/blocked/error)
+ *   - worktree-sync              syncStateToProjectRoot snapshot
+ *   - canonical-root-redirect    resolveCanonicalMilestoneRoot redirected
+ *
+ * These events are purely observational. They never block, never throw,
+ * and never carry code content — only IDs, counts, durations, and reasons.
+ */
+import { randomUUID } from "node:crypto";
+import { emitJournalEvent, queryJournal } from "./journal.js";
+function now() {
+    return new Date().toISOString();
+}
+function baseEntry(eventType, data) {
+    return {
+        ts: now(),
+        flowId: (typeof data.flowId === "string" ? data.flowId : undefined) ?? randomUUID(),
+        seq: typeof data.seq === "number" ? data.seq : 0,
+        eventType,
+        data,
+    };
+}
+// ─── Emitters ────────────────────────────────────────────────────────────
+export function emitWorktreeCreated(projectRoot, milestoneId, meta = {}) {
+    emitJournalEvent(projectRoot, baseEntry("worktree-created", {
+        milestoneId,
+        startedAt: now(),
+        flowId: meta.flowId,
+        reason: meta.reason ?? "enter-milestone",
+    }));
+}
+export function emitWorktreeMerged(projectRoot, milestoneId, meta = {}) {
+    emitJournalEvent(projectRoot, baseEntry("worktree-merged", {
+        milestoneId,
+        endedAt: now(),
+        flowId: meta.flowId,
+        reason: meta.reason ?? "other",
+        startedAt: meta.startedAt,
+        durationMs: meta.durationMs,
+        sliceCount: meta.sliceCount,
+        taskCount: meta.taskCount,
+        conflict: meta.conflict ?? false,
+        conflictedFiles: meta.conflictedFiles ?? 0,
+    }));
+}
+export function emitWorktreeOrphaned(projectRoot, milestoneId, meta) {
+    emitJournalEvent(projectRoot, baseEntry("worktree-orphaned", {
+        milestoneId,
+        flowId: meta.flowId,
+        reason: meta.reason,
+        commitsAhead: meta.commitsAhead,
+        worktreeDirExists: meta.worktreeDirExists ?? false,
+        detectedAt: now(),
+    }));
+}
+export function emitAutoExit(projectRoot, meta) {
+    emitJournalEvent(projectRoot, baseEntry("auto-exit", {
+        reason: meta.reason,
+        flowId: meta.flowId,
+        milestoneId: meta.milestoneId,
+        milestoneMerged: meta.milestoneMerged,
+        exitedAt: now(),
+    }));
+}
+export function emitWorktreeSync(projectRoot, milestoneId, meta) {
+    emitJournalEvent(projectRoot, baseEntry("worktree-sync", {
+        milestoneId,
+        flowId: meta.flowId,
+        filesCopied: meta.filesCopied,
+        bytesCopied: meta.bytesCopied,
+        commitsAhead: meta.commitsAhead,
+        worktreeAgeMs: meta.worktreeAgeMs,
+    }));
+}
+export function emitCanonicalRootRedirect(projectRoot, milestoneId, redirectedTo, meta = {}) {
+    emitJournalEvent(projectRoot, baseEntry("canonical-root-redirect", {
+        milestoneId,
+        redirectedTo,
+        flowId: meta.flowId,
+    }));
+}
+// #4765 — slice-cadence collapse events
+export function emitSliceMerged(projectRoot, milestoneId, sliceId, meta = {}) {
+    emitJournalEvent(projectRoot, baseEntry("slice-merged", {
+        milestoneId,
+        sliceId,
+        mergedAt: now(),
+        durationMs: meta.durationMs,
+        conflict: meta.conflict ?? false,
+        commitSha: meta.commitSha,
+        flowId: meta.flowId,
+    }));
+}
+export function emitMilestoneResquash(projectRoot, milestoneId, meta = { sliceCount: 0 }) {
+    emitJournalEvent(projectRoot, baseEntry("milestone-resquash", {
+        milestoneId,
+        sliceCount: meta.sliceCount,
+        startSha: meta.startSha,
+        endSha: meta.endSha,
+        resquashedAt: now(),
+        flowId: meta.flowId,
+    }));
+}
+/**
+ * Summarize worktree telemetry across the journal. Optional time window
+ * via filters.after / filters.before (ISO-8601).
+ */
+export function summarizeWorktreeTelemetry(projectRoot, filters) {
+    const entries = queryJournal(projectRoot, filters);
+    const summary = {
+        worktreesCreated: 0,
+        worktreesMerged: 0,
+        orphansDetected: 0,
+        orphansByReason: {},
+        mergeDurationsMs: [],
+        mergeConflicts: 0,
+        exitsByReason: {},
+        exitsWithUnmergedWork: 0,
+        canonicalRedirects: 0,
+        slicesMerged: 0,
+        sliceMergeConflicts: 0,
+        milestoneResquashes: 0,
+    };
+    for (const e of entries) {
+        const d = e.data ?? {};
+        switch (e.eventType) {
+            case "worktree-created":
+                summary.worktreesCreated++;
+                break;
+            case "worktree-merged":
+                summary.worktreesMerged++;
+                if (typeof d.durationMs === "number")
+                    summary.mergeDurationsMs.push(d.durationMs);
+                if (d.conflict === true)
+                    summary.mergeConflicts++;
+                break;
+            case "worktree-orphaned": {
+                summary.orphansDetected++;
+                const reason = typeof d.reason === "string" ? d.reason : "unknown";
+                summary.orphansByReason[reason] = (summary.orphansByReason[reason] ?? 0) + 1;
+                break;
+            }
+            case "auto-exit": {
+                const reason = typeof d.reason === "string" ? d.reason : "unknown";
+                summary.exitsByReason[reason] = (summary.exitsByReason[reason] ?? 0) + 1;
+                if (d.milestoneMerged === false)
+                    summary.exitsWithUnmergedWork++;
+                break;
+            }
+            case "canonical-root-redirect":
+                summary.canonicalRedirects++;
+                break;
+            case "slice-merged":
+                summary.slicesMerged++;
+                if (d.conflict === true)
+                    summary.sliceMergeConflicts++;
+                break;
+            case "milestone-resquash":
+                summary.milestoneResquashes++;
+                break;
+            default:
+                break;
+        }
+    }
+    summary.mergeDurationsMs.sort((a, b) => a - b);
+    return summary;
+}
+/**
+ * Return the p{quantile} of a sorted array using the nearest-rank method.
+ * Quantile in [0,1].
+ *
+ * Prior implementation used Math.floor(q*n), which overstates exact-rank
+ * quantiles by one sample (e.g. p95 of 20 values returned the max instead
+ * of the 19th value). The nearest-rank index is ceil(q*n) - 1, clamped to
+ * [0, n-1].
+ */
+export function percentile(sortedValues, q) {
+    if (sortedValues.length === 0)
+        return null;
+    if (q <= 0)
+        return sortedValues[0];
+    if (q >= 1)
+        return sortedValues[sortedValues.length - 1];
+    const idx = Math.min(sortedValues.length - 1, Math.max(0, Math.ceil(q * sortedValues.length) - 1));
+    return sortedValues[idx];
+}

package/dist/resources/extensions/mcp-client/auth.js

@@ -10,7 +10,16 @@
 // ─── Env resolution ───────────────────────────────────────────────────────────
 /** Resolve `${VAR}` references in a string against `process.env`. */
 function resolveEnvValue(value) {
-    return value.replace(/\$\{([^}]+)\}/g, (_match, varName) => process.env[varName] ?? "");
+    return value.replace(/\$\{([^}]+)\}/g, (_match, varName) => {
+        const resolved = process.env[varName];
+        if (resolved === undefined || resolved === "") {
+            // eslint-disable-next-line no-console
+            console.warn(`[mcp-client auth] Environment variable "${varName}" referenced in MCP server config is unset. ` +
+                `Requests will go out with a malformed header and the remote server will likely reject them with 401.`);
+            return "";
+        }
+        return resolved;
+    });
 }
 function resolveHeaders(raw) {
     const resolved = {};

package/dist/resources/extensions/mcp-client/index.js

@@ -21,8 +21,38 @@ import { join } from "node:path";
 import { buildHttpTransportOpts } from "./auth.js";
 // ─── Connection Manager ───────────────────────────────────────────────────────
 const connections = new Map();
+const pendingConnections = new Map();
 let configCache = null;
 const toolCache = new Map();
+const trustedStdioServers = new Set();
+const CHILD_ENV_ALLOWLIST = new Set([
+    "PATH",
+    "Path",
+    "HOME",
+    "USER",
+    "USERNAME",
+    "USERPROFILE",
+    "SHELL",
+    "TMPDIR",
+    "TEMP",
+    "TMP",
+    "SystemRoot",
+    "WINDIR",
+    "APPDATA",
+    "LOCALAPPDATA",
+    "XDG_CONFIG_HOME",
+    "XDG_CACHE_HOME",
+]);
+function stdioTrustKey(config) {
+    return JSON.stringify({
+        name: config.name,
+        sourcePath: config.sourcePath,
+        command: config.command,
+        args: config.args ?? [],
+        cwd: config.cwd,
+        env: config.env ?? {},
+    });
+}
 function readConfigs() {
     if (configCache)
         return configCache;
@@ -57,6 +87,7 @@ function readConfigs() {
                 servers.push({
                     name,
                     transport,
+                    sourcePath: configPath,
                     ...(hasCommand && {
                         command: config.command,
                         args: Array.isArray(config.args) ? config.args : undefined,
@@ -78,6 +109,42 @@ function readConfigs() {
     configCache = servers;
     return servers;
 }
+export function _buildMcpChildEnvForTest(configEnv) {
+    const childEnv = {};
+    for (const key of CHILD_ENV_ALLOWLIST) {
+        const value = process.env[key];
+        if (typeof value === "string")
+            childEnv[key] = value;
+    }
+    return {
+        ...childEnv,
+        ...(configEnv ? resolveEnv(configEnv) : {}),
+    };
+}
+export function _buildMcpTrustConfirmOptionsForTest(signal) {
+    return signal ? { timeout: 120_000, signal } : { timeout: 120_000 };
+}
+async function assertTrustedStdioServer(config, ctx, signal) {
+    if (config.transport !== "stdio")
+        return undefined;
+    const trustKey = stdioTrustKey(config);
+    if (trustedStdioServers.has(trustKey))
+        return undefined;
+    if (!ctx?.hasUI) {
+        throw new Error(`MCP server "${config.name}" is a project-local stdio command from ${config.sourcePath}. ` +
+            "Run this from an interactive GSD session and approve the server before use.");
+    }
+    const commandLine = [config.command, ...(config.args ?? [])].filter(Boolean).join(" ");
+    const envKeys = Object.keys(config.env ?? {});
+    const envSummary = envKeys.length > 0
+        ? `\n\nConfigured environment keys: ${envKeys.join(", ")}`
+        : "\n\nNo explicit environment keys configured.";
+    const approved = await ctx.ui.confirm(`Trust MCP server "${config.name}"?`, `Project config ${config.sourcePath} wants to start:\n\n${commandLine}${envSummary}\n\nOnly approve MCP servers you trust.`, _buildMcpTrustConfirmOptionsForTest(signal));
+    if (!approved) {
+        throw new Error(`MCP server "${config.name}" was not approved by the user.`);
+    }
+    return trustKey;
+}
 function getServerConfig(name) {
     const trimmed = name.trim();
     return readConfigs().find((s) => s.name === trimmed ||
@@ -96,7 +163,7 @@ function resolveEnv(env) {
     }
     return resolved;
 }
-async function getOrConnect(name, signal) {
+async function getOrConnect(name, signal, ctx) {
     const config = getServerConfig(name);
     if (!config)
         throw new Error(`Unknown MCP server: "${name}". Use mcp_servers to list available servers.`);
@@ -105,13 +172,28 @@ async function getOrConnect(name, signal) {
     const existing = connections.get(config.name);
     if (existing)
         return existing.client;
+    const pending = pendingConnections.get(config.name);
+    if (pending)
+        return pending;
+    const connectionPromise = connectServer(config, signal, ctx);
+    pendingConnections.set(config.name, connectionPromise);
+    try {
+        return await connectionPromise;
+    }
+    finally {
+        pendingConnections.delete(config.name);
+    }
+}
+async function connectServer(config, signal, ctx) {
     const client = new Client({ name: "gsd", version: "1.0.0" });
     let transport;
+    let approvedTrustKey;
     if (config.transport === "stdio" && config.command) {
+        approvedTrustKey = await assertTrustedStdioServer(config, ctx, signal);
         transport = new StdioClientTransport({
             command: config.command,
             args: config.args,
-            env: config.env ? { ...process.env, ...resolveEnv(config.env) } : undefined,
+            env: _buildMcpChildEnvForTest(config.env),
             cwd: config.cwd,
             stderr: "pipe",
         });
@@ -127,9 +209,28 @@ async function getOrConnect(name, signal) {
     else {
         throw new Error(`Server "${config.name}" has unsupported transport: ${config.transport}`);
     }
-    await client.connect(transport, { signal, timeout: 30000 });
-    connections.set(config.name, { client, transport });
-    return client;
+    try {
+        await client.connect(transport, { signal, timeout: 30000 });
+        if (approvedTrustKey)
+            trustedStdioServers.add(approvedTrustKey);
+        connections.set(config.name, { client, transport });
+        return client;
+    }
+    catch (err) {
+        try {
+            await transport.close();
+        }
+        catch {
+            // Best-effort cleanup after a failed or aborted connection attempt.
+        }
+        try {
+            await client.close();
+        }
+        catch {
+            // Best-effort cleanup after a failed or aborted connection attempt.
+        }
+        throw err;
+    }
 }
 async function closeAll() {
     const closing = Array.from(connections.entries()).map(async ([name, conn]) => {
@@ -139,9 +240,17 @@ async function closeAll() {
         catch {
             // Best-effort cleanup
         }
+        try {
+            await conn.transport.close();
+        }
+        catch {
+            // Best-effort cleanup
+        }
         connections.delete(name);
     });
     await Promise.allSettled(closing);
+    pendingConnections.clear();
+    trustedStdioServers.clear();
     toolCache.clear();
 }
 // ─── Formatters ───────────────────────────────────────────────────────────────
@@ -249,7 +358,7 @@ export default function (pi) {
                 description: "MCP server name (from mcp_servers output), e.g. 'railway', 'twitter-mcp', 'linear'",
             }),
         }),
-        async execute(_id, params, signal) {
+        async execute(_id, params, signal, _onUpdate, ctx) {
             try {
                 // Return cached tools if available
                 const cached = toolCache.get(params.server);
@@ -265,7 +374,7 @@ export default function (pi) {
                         details: { server: params.server, toolCount: cached.length, cached: true },
                     };
                 }
-                const client = await getOrConnect(params.server, signal);
+                const client = await getOrConnect(params.server, signal, ctx);
                 const result = await client.listTools(undefined, { signal, timeout: 30000 });
                 const tools = (result.tools ?? []).map((t) => ({
                     name: t.name,
@@ -326,9 +435,9 @@ export default function (pi) {
                 description: "Tool arguments as key-value pairs matching the tool's input schema",
             })),
         }),
-        async execute(_id, params, signal) {
+        async execute(_id, params, signal, _onUpdate, ctx) {
             try {
-                const client = await getOrConnect(params.server, signal);
+                const client = await getOrConnect(params.server, signal, ctx);
                 const result = await client.callTool({ name: params.tool, arguments: params.args ?? {} }, undefined, { signal, timeout: 60000 });
                 // Serialize result content to text
                 const contentItems = result.content;
@@ -398,7 +507,7 @@ export default function (pi) {
     pi.on("session_shutdown", async () => {
         await closeAll();
     });
-    pi.on("session_before_switch", async () => {
+    pi.on("session_switch", async () => {
         await closeAll();
         configCache = null;
     });

package/dist/resources/extensions/ollama/index.js

@@ -63,11 +63,12 @@ async function probeAndRegister(pi) {
     // so the "ollama" fallback is harmless. For cloud endpoints (OLLAMA_HOST pointing
     // to ollama.com or a remote instance), OLLAMA_API_KEY is picked up here.
     pi.registerProvider("ollama", {
-        // authMode and isReady removed from ProviderConfig in pi 0.67.2
+        authMode: "apiKey",
         apiKey: process.env.OLLAMA_API_KEY ?? "ollama",
         baseUrl,
         api: "ollama-chat",
         streamSimple: streamOllamaChat,
+        isReady: () => true,
         models: models.map((m) => ({
             id: m.id,
             name: m.name,

package/dist/resources/extensions/ollama/ollama-chat-provider.js

@@ -126,7 +126,7 @@ export function streamOllamaChat(model, context, options) {
                         processChunks(thinkParser.flush());
                     endBlock();
                     output.usage = buildUsage(chunk);
-                    // inferenceMetrics removed from AssistantMessage in pi 0.67.2
+                    output.inferenceMetrics = extractMetrics(chunk);
                     // Preserve "toolUse" if tool calls were processed
                     if (output.stopReason !== "toolUse") {
                         output.stopReason = mapStopReason(chunk.done_reason);
@@ -145,7 +145,6 @@ export function streamOllamaChat(model, context, options) {
 }
 // ─── Request building ───────────────────────────────────────────────────────
 function buildRequest(model, context, options) {
-    // providerOptions removed from Model in pi 0.67.2; cast via unknown for extension data
     const ollamaOpts = (model.providerOptions ?? {});
     const request = {
         model: model.id,
@@ -320,9 +319,20 @@ function buildUsage(chunk) {
         cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
     };
 }
-// extractMetrics removed: InferenceMetrics was removed from pi-ai in pi 0.67.2
-// and inferenceMetrics was removed from AssistantMessage. Ollama perf metrics
-// (tokensPerSecond, evalDurationMs, etc.) are no longer surfaced via this path.
+function extractMetrics(chunk) {
+    if (!chunk.eval_duration && !chunk.total_duration)
+        return undefined;
+    const evalCount = chunk.eval_count ?? 0;
+    const evalDurationNs = chunk.eval_duration ?? 0;
+    const evalDurationMs = evalDurationNs / 1e6;
+    const tokensPerSecond = evalDurationNs > 0 ? evalCount / (evalDurationNs / 1e9) : 0;
+    return {
+        tokensPerSecond,
+        totalDurationMs: (chunk.total_duration ?? 0) / 1e6,
+        evalDurationMs,
+        promptEvalDurationMs: (chunk.prompt_eval_duration ?? 0) / 1e6,
+    };
+}
 // ─── Stream lifecycle helpers ───────────────────────────────────────────────
 // Replicated from openai-shared.ts (not exported from @gsd/pi-ai)
 function buildInitialOutput(model) {

package/dist/resources/extensions/remote-questions/config.js

@@ -40,20 +40,9 @@ function hydrateRemoteTokensFromAuth() {
         return;
     try {
         const auth = AuthStorage.create();
-        const authData = auth.data ?? {};
         for (const [providerId, envVar] of needed) {
             try {
-                const raw = authData[providerId];
-                const creds = Array.isArray(raw)
-                    ? raw
-                    : raw
-                        ? [raw]
-                        : [];
-                if (creds.length === 0) {
-                    const fallbackCred = auth.get(providerId);
-                    if (fallbackCred)
-                        creds.push(fallbackCred);
-                }
+                const creds = auth.getCredentialsForProvider(providerId);
                 const apiKeyCred = creds.find((c) => c.type === "api_key" && !!c.key);
                 if (apiKeyCred?.key) {
                     process.env[envVar] = apiKeyCred.key;