oh-my-knowledge 0.51.2 → 0.52.0

package/dist/renderer/observation-inbox-renderer.js

@@ -1886,10 +1886,13 @@ export function renderObservationInboxPage(model, lang = DEFAULT_LANG) {
                 user_message: '用户消息',
                 synthetic_user_event: '构造事件',
                 assistant_message: '助手回复',
+                model_activity: '模型活动',
+                agent_activity: '协作代理活动',
                 tool_use: '工具调用',
                 tool_result: '工具结果',
                 skill_context: '能力说明',
                 runtime_context: '运行注入',
+                lifecycle: '运行状态',
                 observation: '过程发现',
             };
             return labels[kind] ?? kind;
@@ -2393,6 +2396,8 @@ export function renderObservationInboxPage(model, lang = DEFAULT_LANG) {
             return { icon: 'S', label: 'Skill 注入上下文', tone: 'skill' };
         if (event.kind === 'runtime_context')
             return { icon: 'R', label: event.label === 'command envelope' ? '命令注入上下文' : '运行时注入上下文', tone: 'skill' };
+        if (event.kind === 'lifecycle')
+            return { icon: 'L', label: '运行状态', tone: 'runtime' };
         return { icon: 'O', label: '过程发现', tone: 'observation' };
     };
     const isSkillLaunchResult = (event) => event.kind === 'tool_result' && /^Launching skill:/i.test((event.fullText ?? event.snippet ?? '').trim());
@@ -2629,6 +2634,9 @@ export function renderObservationInboxPage(model, lang = DEFAULT_LANG) {
         if (event.kind === 'runtime_context') {
             badges.push({ label: '不计入用户交互', className: 'metric-skill-context', title: event.label === 'command envelope' ? '这是斜杠命令的系统包装内容，不是人工用户原话，不计入用户消息、追问、纠正、情绪反馈或用户硬性要求。' : '这是 SDK/工作台注入的运行时上下文，不是人工用户原话，不计入用户消息、追问、纠正、情绪反馈或用户硬性要求。' });
         }
+        if (event.kind === 'lifecycle') {
+            badges.push({ label: '运行状态', className: 'metric-neutral', title: '这是 runtime 记录的生命周期状态，不是模型上下文，也不计入用户交互。' });
+        }
         if (event.kind === 'observation') {
             badges.push({ label: '过程发现来源', className: 'metric-explicit', title: '这条事件来自 observation 信号，会进入过程发现类指标。' });
         }
@@ -5157,6 +5165,7 @@ export function renderObservationInboxPage(model, lang = DEFAULT_LANG) {
 	        <span>入口 ${e(inboxEntrypointShort(session))}</span>
 	        <span>调用段 ${session.invocationIds.length}</span>
 	        <span>工具调用 ${indicators.toolCallCount}</span>
+	        <a href="/conversations/${encodeURIComponent(session.threadId)}${lang === DEFAULT_LANG ? '' : `?lang=${lang}`}" onclick="event.stopPropagation()">${lang === 'zh' ? '查看对话任务' : 'Conversation tasks'}</a>
 	      </div>
 	      ${navHtml}
 	      <template id="${flowTemplateId}">${inboxRenderSessionFlow(cardSkillName, session, siblings, flowSummaryText)}</template>

package/dist/renderer/skill-list-renderer.js

@@ -90,7 +90,8 @@ function renderPanel(a, lang) {
     <h1>${zh ? 'Skill 健康评测工作台' : 'Skill Health Dashboard'}</h1>
     <span class="phead-sub">${a.totalSkills} ${zh ? '个 skill' : 'skills'}</span>
     <span class="phead-when">${icon('clock', { size: 13 })} ${zh ? '更新于' : 'updated'} ${fmtDate(a.lastTs)}</span>
-    <a href="/managed${zh ? '' : '?lang=en'}" style="margin-left:auto;font-size:13px;color:var(--accent);text-decoration:none;white-space:nowrap">${zh ? '受管决策史' : 'Managed history'} →</a>
+    <a href="/${zh ? '' : '?lang=en'}" style="margin-left:auto;font-size:13px;color:var(--accent);text-decoration:none;white-space:nowrap">${zh ? '对话总览' : 'Conversation overview'} →</a>
+    <a href="/managed${zh ? '' : '?lang=en'}" style="font-size:13px;color:var(--accent);text-decoration:none;white-space:nowrap">${zh ? '受管决策史' : 'Managed history'} →</a>
   </div>`;
     // 综合健康(细线总览首格):ring + 标签 + 说明入口。
     const ovMain = `<div class="ov-cell ov-main">

package/dist/renderer/trajectory-live.d.ts

@@ -0,0 +1,42 @@
+export interface TrajectoryLiveLabels {
+    connecting: string;
+    live: string;
+    syncing: string;
+    reconnecting: string;
+    failed: string;
+    following: string;
+    resume: string;
+    pending: string;
+    completed: string;
+    aborted: string;
+    interrupted: string;
+    unknown: string;
+    pauseTitle: string;
+}
+export interface TrajectoryLiveClientOptions {
+    shell: HTMLElement;
+    timeline: HTMLElement | null;
+    liveState: HTMLElement | null;
+    followButton: HTMLButtonElement | null;
+    followLabel: HTMLElement | null;
+    liveEndpoint: string;
+    labels: TrajectoryLiveLabels;
+    getMode: () => string;
+    setMode: (mode: string) => void;
+    isScrollTrackingSuppressed?: () => boolean;
+    refreshSnapshot?: (state: TrajectoryLiveViewState) => Promise<void>;
+    browserWindow: Window;
+    browserDocument: Document;
+}
+export interface TrajectoryLiveViewState {
+    mode: string;
+    scrollLeft: number;
+    followLatest: boolean;
+    animateToLatest?: boolean;
+}
+export interface TrajectoryLiveController {
+    pauseFollowing: () => void;
+    dispose: () => void;
+}
+export declare function createTrajectoryLiveController(options: TrajectoryLiveClientOptions): TrajectoryLiveController;
+export declare function renderTrajectoryLiveClientSource(): string;

package/dist/renderer/trajectory-live.js

@@ -0,0 +1,258 @@
+export function createTrajectoryLiveController(options) {
+    const { shell, timeline, liveState, followButton, followLabel, liveEndpoint, labels, browserWindow, browserDocument, } = options;
+    const stateKey = `omk:live-trajectory:${browserWindow.location.pathname}`;
+    const lifecycle = new AbortController();
+    let followLatest = Boolean(liveEndpoint);
+    let pendingRevision = '';
+    let terminalState;
+    let refreshTimer;
+    let scrollReleaseTimer;
+    let suppressScrollTracking = false;
+    let liveSource;
+    const setConnectionState = (state, label) => {
+        if (!liveState)
+            return;
+        liveState.dataset.state = state;
+        liveState.textContent = label;
+    };
+    const isNearLatest = () => {
+        if (!timeline)
+            return true;
+        const remaining = timeline.scrollWidth - timeline.clientWidth - timeline.scrollLeft;
+        return remaining <= 72;
+    };
+    const scrollToLatest = (smooth = false) => {
+        if (!timeline || options.getMode() !== 'semantic')
+            return;
+        suppressScrollTracking = true;
+        const left = Math.max(0, timeline.scrollWidth - timeline.clientWidth);
+        const reduceMotion = browserWindow.matchMedia?.('(prefers-reduced-motion: reduce)').matches;
+        if (smooth && !reduceMotion && typeof timeline.scrollTo === 'function') {
+            timeline.scrollTo({ left, behavior: 'smooth' });
+            if (scrollReleaseTimer !== undefined)
+                browserWindow.clearTimeout(scrollReleaseTimer);
+            scrollReleaseTimer = browserWindow.setTimeout(() => {
+                timeline.scrollLeft = left;
+                suppressScrollTracking = false;
+                scrollReleaseTimer = undefined;
+            }, 700);
+        }
+        else {
+            timeline.scrollLeft = left;
+            browserWindow.requestAnimationFrame(() => { suppressScrollTracking = false; });
+        }
+    };
+    const updateFollowControl = () => {
+        if (!followButton || !followLabel)
+            return;
+        const state = terminalState ?? (!followLatest && pendingRevision
+            ? 'pending'
+            : (followLatest ? 'following' : 'paused'));
+        const terminalLabel = terminalState ? labels[terminalState] : undefined;
+        followButton.dataset.state = state;
+        followButton.dataset.following = String(followLatest);
+        followButton.setAttribute('aria-pressed', String(followLatest));
+        followLabel.textContent = terminalLabel ?? (state === 'pending'
+            ? labels.pending
+            : state === 'following'
+                ? labels.following
+                : labels.resume);
+        followButton.title = state === 'following' ? labels.pauseTitle : followLabel.textContent;
+    };
+    const setFollowing = (next, shouldScroll = next) => {
+        if (!next && refreshTimer !== undefined) {
+            browserWindow.clearTimeout(refreshTimer);
+            refreshTimer = undefined;
+            setConnectionState('live', labels.live);
+        }
+        followLatest = next;
+        updateFollowControl();
+        if (shouldScroll)
+            scrollToLatest(true);
+    };
+    const readViewState = () => {
+        try {
+            const raw = browserWindow.sessionStorage.getItem(stateKey);
+            browserWindow.sessionStorage.removeItem(stateKey);
+            return raw ? JSON.parse(raw) : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const currentViewState = (animateToLatest = false) => ({
+        mode: options.getMode(),
+        scrollLeft: timeline?.scrollLeft ?? 0,
+        followLatest,
+        ...(animateToLatest ? { animateToLatest: true } : {}),
+    });
+    const saveViewState = (state = currentViewState()) => {
+        try {
+            browserWindow.sessionStorage.setItem(stateKey, JSON.stringify(state));
+        }
+        catch {
+            // Storage can be unavailable in hardened browsers.
+        }
+    };
+    const restoreViewState = () => {
+        const state = readViewState();
+        if (state?.mode && ['semantic', 'normalized', 'source'].includes(state.mode))
+            options.setMode(state.mode);
+        if (typeof state?.followLatest === 'boolean')
+            followLatest = state.followLatest;
+        if (!liveEndpoint || options.getMode() !== 'semantic')
+            followLatest = false;
+        updateFollowControl();
+        if (timeline && Number.isFinite(state?.scrollLeft)) {
+            // Browsers can dispatch this assignment's scroll event after listeners are attached below.
+            // Keep restoration programmatic until the final frame settles so it cannot pause live follow.
+            suppressScrollTracking = true;
+            timeline.scrollLeft = Math.min(state?.scrollLeft ?? 0, Math.max(0, timeline.scrollWidth - timeline.clientWidth));
+        }
+        browserWindow.requestAnimationFrame(() => {
+            browserWindow.requestAnimationFrame(() => {
+                if (followLatest && liveEndpoint)
+                    scrollToLatest(Boolean(state?.animateToLatest));
+                else if (timeline && Number.isFinite(state?.scrollLeft)) {
+                    timeline.scrollLeft = state?.scrollLeft ?? 0;
+                    browserWindow.requestAnimationFrame(() => { suppressScrollTracking = false; });
+                }
+                else {
+                    suppressScrollTracking = false;
+                }
+            });
+        });
+    };
+    const reloadNow = async () => {
+        if (!pendingRevision)
+            return;
+        if (refreshTimer !== undefined)
+            browserWindow.clearTimeout(refreshTimer);
+        if (scrollReleaseTimer !== undefined)
+            browserWindow.clearTimeout(scrollReleaseTimer);
+        refreshTimer = undefined;
+        scrollReleaseTimer = undefined;
+        setConnectionState('syncing', labels.syncing);
+        // Live snapshots can arrive faster than native smooth scrolling settles.
+        // Restore them at the latest edge immediately so following never lags behind.
+        const viewState = currentViewState();
+        saveViewState(viewState);
+        if (options.refreshSnapshot) {
+            const revision = pendingRevision;
+            pendingRevision = '';
+            updateFollowControl();
+            try {
+                await options.refreshSnapshot(viewState);
+            }
+            catch {
+                pendingRevision = revision;
+                setConnectionState('reconnecting', labels.reconnecting);
+                updateFollowControl();
+            }
+            return;
+        }
+        browserWindow.location.reload();
+    };
+    const applyPendingUpdate = () => {
+        updateFollowControl();
+        if (!pendingRevision
+            || !followLatest
+            || options.getMode() !== 'semantic'
+            || browserDocument.hidden
+            || refreshTimer !== undefined)
+            return;
+        setConnectionState('syncing', labels.syncing);
+        refreshTimer = browserWindow.setTimeout(() => { void reloadNow(); }, 600);
+    };
+    const pauseFollowing = () => {
+        if (!liveEndpoint || !followLatest)
+            return;
+        setFollowing(false, false);
+    };
+    const dispose = () => {
+        lifecycle.abort();
+        liveSource?.close();
+        if (refreshTimer !== undefined)
+            browserWindow.clearTimeout(refreshTimer);
+        if (scrollReleaseTimer !== undefined)
+            browserWindow.clearTimeout(scrollReleaseTimer);
+        refreshTimer = undefined;
+        scrollReleaseTimer = undefined;
+    };
+    restoreViewState();
+    timeline?.addEventListener('scroll', () => {
+        if (suppressScrollTracking
+            || options.isScrollTrackingSuppressed?.()
+            || !followLatest
+            || options.getMode() !== 'semantic')
+            return;
+        if (!isNearLatest())
+            pauseFollowing();
+    }, { passive: true, signal: lifecycle.signal });
+    followButton?.addEventListener('click', () => {
+        if (pendingRevision && !followLatest) {
+            setFollowing(true, false);
+            void reloadNow();
+            return;
+        }
+        setFollowing(!followLatest);
+    }, { signal: lifecycle.signal });
+    browserDocument.addEventListener('visibilitychange', () => {
+        if (!browserDocument.hidden)
+            applyPendingUpdate();
+    }, { signal: lifecycle.signal });
+    browserWindow.addEventListener('pagehide', dispose, { once: true, signal: lifecycle.signal });
+    const EventSourceConstructor = browserWindow.EventSource;
+    if (liveEndpoint && EventSourceConstructor) {
+        setConnectionState('connecting', labels.connecting);
+        const source = new EventSourceConstructor(liveEndpoint);
+        liveSource = source;
+        source.addEventListener('open', () => setConnectionState('live', labels.live), { signal: lifecycle.signal });
+        source.addEventListener('trajectory', (event) => {
+            try {
+                const update = JSON.parse(event.data);
+                const explicitTerminal = update.status === 'completed'
+                    || update.status === 'aborted'
+                    || update.status === 'interrupted';
+                const streamTerminal = update.liveObservable === false || explicitTerminal;
+                terminalState = explicitTerminal
+                    ? update.status
+                    : update.liveObservable === false ? 'unknown' : undefined;
+                if (streamTerminal) {
+                    source.close();
+                    if (liveSource === source)
+                        liveSource = undefined;
+                }
+                if (!update.revision || update.revision === shell.dataset.liveRevision) {
+                    const quiet = update.status === 'unknown';
+                    const connectionLabel = terminalState
+                        ? labels[terminalState]
+                        : quiet ? labels.reconnecting : labels.live;
+                    setConnectionState(terminalState ?? (quiet ? 'reconnecting' : 'live'), connectionLabel);
+                    updateFollowControl();
+                    return;
+                }
+                pendingRevision = update.revision;
+                applyPendingUpdate();
+            }
+            catch {
+                // Ignore malformed live events and wait for the next revision.
+            }
+        }, { signal: lifecycle.signal });
+        source.addEventListener('trajectory-error', () => {
+            source.close();
+            if (liveSource === source)
+                liveSource = undefined;
+            setConnectionState('failed', labels.failed);
+        }, { signal: lifecycle.signal });
+        source.addEventListener('error', () => {
+            if (!pendingRevision)
+                setConnectionState('reconnecting', labels.reconnecting);
+        }, { signal: lifecycle.signal });
+    }
+    return { pauseFollowing, dispose };
+}
+export function renderTrajectoryLiveClientSource() {
+    // Studio 页面没有独立客户端打包链路；序列化已类型检查的控制器，避免维护第二份浏览器实现。
+    return createTrajectoryLiveController.toString();
+}

package/dist/renderer/trajectory-routing.d.ts

@@ -0,0 +1,60 @@
+export interface RoutingPoint {
+    x: number;
+    y: number;
+}
+export interface RoutingRect<Owner = unknown> {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    owner?: Owner;
+}
+export interface HorizontalObstacleIndex<Owner = unknown> {
+    bucketSize: number;
+    buckets: Map<number, RoutingRect<Owner>[]>;
+    all: RoutingRect<Owner>[];
+}
+export interface FlowRouteMetrics {
+    obstacleQueries: number;
+    obstacleCandidates: number;
+    collisionChecks: number;
+    curveCandidates: number;
+    corridorCandidates: number;
+}
+export interface FlowRoutePlan {
+    routeKind: 'straight' | 'quadratic' | 'corridor';
+    d: string;
+    from: RoutingPoint;
+    to: RoutingPoint;
+    arrowFrom: RoutingPoint;
+    metrics: FlowRouteMetrics;
+}
+export interface FlowRouteRequest<Owner = unknown> {
+    fromRect: RoutingRect<Owner>;
+    toRect: RoutingRect<Owner>;
+    fromLane: string;
+    toLane: string;
+    obstacleIndex: HorizontalObstacleIndex<Owner>;
+    fromOwner?: Owner;
+    toOwner?: Owner;
+}
+export declare function planFlowMarkerProgresses(pathLength: number, markerCount: number): number[];
+export declare function createHorizontalObstacleIndex<Owner>(rects: RoutingRect<Owner>[], bucketSize?: number): HorizontalObstacleIndex<Owner>;
+export declare function queryHorizontalObstacleIndex<Owner>(index: HorizontalObstacleIndex<Owner>, minX: number, maxX: number, minY?: number, maxY?: number): RoutingRect<Owner>[];
+export declare function routingPointInsideRect(point: RoutingPoint, rect: RoutingRect): boolean;
+export declare function routingLineHitsRect(fromPoint: RoutingPoint, toPoint: RoutingPoint, rect: RoutingRect): boolean;
+export declare function routingQuadraticHitsRect(fromPoint: RoutingPoint, control: RoutingPoint, toPoint: RoutingPoint, rect: RoutingRect): boolean;
+export declare function routingMoveToward(fromPoint: RoutingPoint, toPoint: RoutingPoint, distance: number): RoutingPoint;
+export declare function routingEdgePoint(rect: RoutingRect, targetX: number, targetY: number): RoutingPoint;
+export declare function routingConnectionPoints(fromRect: RoutingRect, toRect: RoutingRect): {
+    from: RoutingPoint;
+    to: RoutingPoint;
+};
+export declare function routingRectPort(rect: RoutingRect, side: 'left' | 'right' | 'top' | 'bottom'): RoutingPoint;
+export declare function routingFlowControlPoint(points: {
+    from: RoutingPoint;
+    to: RoutingPoint;
+}, requestedBend?: number, side?: number): RoutingPoint;
+export declare function routingRoundedPolylinePath(routePoints: RoutingPoint[], radius?: number): string;
+export declare function planFlowRoute<Owner>(request: FlowRouteRequest<Owner>): FlowRoutePlan | undefined;
+export declare function renderTrajectoryRoutingClientSource(): string;