pikiclaw 0.2.55 → 0.2.56

package/dist/bot-command-ui.js

@@ -1,5 +1,6 @@
 import { normalizeAgent } from './bot.js';
-import { getAgentsListData, getModelsListData, getSessionsPageData, getSkillsListData, modelMatchesSelection, resolveSkillPrompt, } from './bot-commands.js';
+import { getSessionStatusForChat } from './session-status.js';
+import { getAgentsListData, getModelsListData, getSessionsPageData, getSkillsListData, summarizeSessionRun, modelMatchesSelection, resolveSkillPrompt, } from './bot-commands.js';
 function chunkRows(items, columns) {
     const rows = [];
     const size = Math.max(1, columns);
@@ -219,13 +220,14 @@ export async function executeCommandAction(bot, chatId, action, opts = {}) {
                 return { kind: 'noop', message: 'Session not found' };
             const runtime = bot.adoptExistingSessionForChat(chatId, session);
             const displayId = session.sessionId || action.sessionId;
+            const sessionStatus = getSessionStatusForChat(bot, chat, session);
             return {
                 kind: 'notice',
                 callbackText: `Switched: ${displayId.slice(0, 12)}`,
                 notice: {
                     title: 'Session Switched',
                     value: displayId,
-                    detail: 'Switched successfully',
+                    detail: summarizeSessionRun({ ...session, running: sessionStatus.isRunning }).noticeDetail,
                     valueMode: 'code',
                 },
                 session: runtime,

package/dist/bot-commands.js

@@ -37,6 +37,28 @@ export function getStartData(bot, chatId) {
         commands,
     };
 }
+export function summarizeSessionRun(session) {
+    if (session.running || session.runState === 'running') {
+        return {
+            state: 'running',
+            shortLabel: 'running',
+            noticeDetail: 'Status: running',
+        };
+    }
+    if (session.runState === 'incomplete') {
+        const detail = String(session.runDetail || '').trim();
+        return {
+            state: 'incomplete',
+            shortLabel: 'unfinished',
+            noticeDetail: detail ? `Status: unfinished · ${detail}` : 'Status: unfinished',
+        };
+    }
+    return {
+        state: 'completed',
+        shortLabel: 'done',
+        noticeDetail: 'Status: completed',
+    };
+}
 export async function getSessionsPageData(bot, chatId, page, pageSize = 5) {
     const cs = bot.chat(chatId);
     const res = await bot.fetchSessions(cs.agent);
@@ -51,11 +73,24 @@ export async function getSessionsPageData(bot, chatId, page, pageSize = 5) {
         if (!sessionKey)
             continue;
         const status = getSessionStatusForChat(bot, cs, s);
+        const runSummary = summarizeSessionRun({
+            running: status.isRunning,
+            runState: status.isRunning ? 'running' : s.runState,
+            runDetail: s.runDetail,
+        });
         const title = s.title ? s.title.replace(/\n/g, ' ').slice(0, 10) : sessionKey.slice(0, 10);
         const time = s.createdAt
             ? new Date(s.createdAt).toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit' })
             : '?';
-        entries.push({ key: sessionKey, title, time, isCurrent: status.isCurrent, isRunning: status.isRunning });
+        entries.push({
+            key: sessionKey,
+            title,
+            time: `${time} · ${runSummary.shortLabel}`,
+            isCurrent: status.isCurrent,
+            isRunning: status.isRunning,
+            runState: runSummary.state,
+            runDetail: s.runDetail,
+        });
     }
     return { agent: cs.agent, total, page: pg, totalPages, sessions: entries };
 }

package/dist/code-agent.js

@@ -464,6 +464,54 @@ function nextPendingSessionId() { return `pending_${crypto.randomBytes(6).toStri
 export function isPendingSessionId(sessionId) {
     return typeof sessionId === 'string' && sessionId.startsWith('pending_');
 }
+function normalizeSessionRunState(rawState) {
+    const state = typeof rawState === 'string' ? rawState.trim().toLowerCase() : '';
+    if (state === 'completed' || state === 'incomplete')
+        return state;
+    if (state === 'running')
+        return 'incomplete';
+    return 'completed';
+}
+function normalizeSessionRunDetail(rawState, rawDetail) {
+    const detail = typeof rawDetail === 'string' ? rawDetail.trim() : '';
+    if (detail)
+        return shortValue(detail, 180);
+    const state = typeof rawState === 'string' ? rawState.trim().toLowerCase() : '';
+    if (state === 'running')
+        return 'Last run stopped before completion.';
+    return null;
+}
+function normalizeSessionRunUpdatedAt(rawUpdatedAt, fallback) {
+    return typeof rawUpdatedAt === 'string' && rawUpdatedAt.trim() ? rawUpdatedAt : fallback;
+}
+function setSessionRunState(record, runState, runDetail, runUpdatedAt) {
+    record.runState = runState;
+    record.runDetail = runDetail ? shortValue(runDetail, 180) : null;
+    record.runUpdatedAt = runUpdatedAt || new Date().toISOString();
+}
+function incompleteRunDetail(result) {
+    if (result.stopReason === 'interrupted')
+        return 'Interrupted by user.';
+    if (result.stopReason === 'timeout')
+        return 'Timed out before completion.';
+    if (result.stopReason === 'max_tokens')
+        return 'Stopped before completion: max tokens reached.';
+    const error = normalizeErrorMessage(result.error);
+    if (error)
+        return shortValue(error, 180);
+    const stopReason = normalizeErrorMessage(result.stopReason);
+    if (stopReason)
+        return `Stopped before completion: ${shortValue(stopReason, 120)}`;
+    const message = firstNonEmptyLine(result.message || '');
+    return message ? shortValue(message, 180) : 'Last run did not complete.';
+}
+function applySessionRunResult(record, result) {
+    if (result.ok && !result.incomplete) {
+        setSessionRunState(record, 'completed', null);
+        return;
+    }
+    setSessionRunState(record, 'incomplete', incompleteRunDetail(result));
+}
 function normalizeSessionRecord(raw, workdir) {
     // Support both new format (sessionId) and legacy format (localSessionId + engineSessionId)
     const sessionId = typeof raw?.sessionId === 'string' ? raw.sessionId.trim()
@@ -484,6 +532,9 @@ function normalizeSessionRecord(raw, workdir) {
         title: typeof raw?.title === 'string' && raw.title.trim() ? raw.title.trim() : null,
         model: typeof raw?.model === 'string' && raw.model.trim() ? raw.model.trim() : null,
         stagedFiles: Array.isArray(raw?.stagedFiles) ? dedupeStrings(raw.stagedFiles.filter((v) => typeof v === 'string')) : [],
+        runState: normalizeSessionRunState(raw?.runState),
+        runDetail: normalizeSessionRunDetail(raw?.runState, raw?.runDetail),
+        runUpdatedAt: normalizeSessionRunUpdatedAt(raw?.runUpdatedAt, typeof raw?.updatedAt === 'string' && raw.updatedAt.trim() ? raw.updatedAt : new Date().toISOString()),
     };
 }
 function loadSessionIndex(workdir) {
@@ -502,6 +553,7 @@ function writeSessionMeta(record) {
         workspacePath: record.workspacePath,
         createdAt: record.createdAt, updatedAt: record.updatedAt,
         title: record.title, model: record.model, stagedFiles: record.stagedFiles,
+        runState: record.runState, runDetail: record.runDetail, runUpdatedAt: record.runUpdatedAt,
     });
 }
 function copyPath(sourcePath, targetPath) {
@@ -583,8 +635,25 @@ export function promoteSessionId(workdir, agent, pendingId, nativeId) {
     record.workspacePath = sessionWorkspacePath(resolvedWorkdir, agent, nativeId);
     saveSessionRecord(resolvedWorkdir, record);
 }
+function syncManagedSessionIdentity(session, workdir, nativeId) {
+    const resolvedId = nativeId.trim();
+    if (!resolvedId || session.sessionId === resolvedId)
+        return false;
+    const resolvedWorkdir = path.resolve(workdir);
+    const previousId = session.sessionId;
+    if (isPendingSessionId(previousId)) {
+        promoteSessionId(resolvedWorkdir, session.record.agent, previousId, resolvedId);
+    }
+    session.sessionId = resolvedId;
+    session.workspacePath = sessionWorkspacePath(resolvedWorkdir, session.record.agent, resolvedId);
+    session.record.sessionId = resolvedId;
+    session.record.workspacePath = session.workspacePath;
+    return true;
+}
 function summarizePromptTitle(prompt) {
-    const text = String(prompt || '').replace(/\s+/g, ' ').trim();
+    const raw = String(prompt || '').replace(/\r\n?/g, '\n');
+    const text = firstNonEmptyLine(raw).replace(/\s+/g, ' ').trim()
+        || raw.replace(/\s+/g, ' ').trim();
     if (!text)
         return null;
     return text.length <= 120 ? text : `${text.slice(0, 117).trimEnd()}...`;
@@ -635,6 +704,7 @@ function ensureSessionWorkspace(opts) {
             workspacePath: sessionWorkspacePath(workdir, opts.agent, sessionId),
             createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(),
             title: summarizePromptTitle(opts.title) || null, model: null, stagedFiles: [],
+            runState: 'completed', runDetail: null, runUpdatedAt: new Date().toISOString(),
         };
     }
     if (!record.title && opts.title)
@@ -799,6 +869,7 @@ function prepareStreamOpts(opts) {
     session.record.stagedFiles = [];
     if (!session.record.title)
         session.record.title = summarizePromptTitle(opts.prompt) || importedFiles[0] || null;
+    setSessionRunState(session.record, 'running', null);
     saveSessionRecord(opts.workdir, session.record);
     const attachmentPaths = attachmentRelPaths.map(relPath => path.join(session.workspacePath, relPath));
     // For pending sessions, pass null sessionId to the CLI so it creates a new session
@@ -811,20 +882,21 @@ function prepareStreamOpts(opts) {
             ...opts,
             sessionId: effectiveSessionId,
             attachments: attachmentPaths.length ? attachmentPaths : undefined,
+            onSessionId: (nativeSessionId) => {
+                if (!syncManagedSessionIdentity(session, opts.workdir, nativeSessionId))
+                    return;
+                saveSessionRecord(opts.workdir, session.record);
+            },
         },
     };
 }
 function finalizeStreamResult(result, workdir, prompt, session) {
-    // If the agent returned a native session ID and our session was pending, promote it
-    const pendingId = session.sessionId;
-    if (result.sessionId && isPendingSessionId(pendingId)) {
-        promoteSessionId(workdir, session.record.agent, pendingId, result.sessionId);
-        session.sessionId = result.sessionId;
-    }
-    session.record.sessionId = result.sessionId || session.record.sessionId;
+    if (result.sessionId)
+        syncManagedSessionIdentity(session, workdir, result.sessionId);
     session.record.model = result.model || session.record.model;
     if (!session.record.title)
         session.record.title = summarizePromptTitle(prompt);
+    applySessionRunResult(session.record, result);
     saveSessionRecord(workdir, session.record);
     return { ...result, sessionId: session.sessionId, workspacePath: session.workspacePath };
 }
@@ -885,6 +957,33 @@ export async function doStream(opts) {
         const result = await driver.doStream(prepared);
         return finalizeStreamResult(result, opts.workdir, opts.prompt, session);
     }
+    catch (error) {
+        const failedResult = {
+            ok: false,
+            message: normalizeErrorMessage(error) || 'Agent stream failed.',
+            thinking: null,
+            sessionId: session.sessionId,
+            workspacePath: session.workspacePath,
+            model: session.record.model,
+            thinkingEffort: prepared.thinkingEffort,
+            elapsedS: 0,
+            inputTokens: null,
+            outputTokens: null,
+            cachedInputTokens: null,
+            cacheCreationInputTokens: null,
+            contextWindow: null,
+            contextUsedTokens: null,
+            contextPercent: null,
+            codexCumulative: null,
+            error: normalizeErrorMessage(error) || 'Agent stream failed.',
+            stopReason: null,
+            incomplete: true,
+            activity: null,
+        };
+        applySessionRunResult(session.record, failedResult);
+        saveSessionRecord(opts.workdir, session.record);
+        throw error;
+    }
     finally {
         if (bridge) {
             await bridge.stop().catch(() => { });