@pagelines/sdk 1.0.652 → 1.0.654

package/dist/agent/AgentController.d.ts

@@ -2,6 +2,7 @@ import { ComputedRef, Ref } from 'vue';
 import { AgentConfig, ChatToolActivityData, SettingsObject } from '@pagelines/core';
 import { PageLinesSDK } from '../sdkClient';
 import { AgentMode, ChatAttachment, ChatMessage, TextConnectionState, Agent } from './schema';
+import { WorkJournalModel, WorkJournalOutcome } from './work-journal';
 import { VoiceRecorderController } from './VoiceRecorderController';
 /**
  * Structured error payload surfaced by the chat stream. Matches the
@@ -65,15 +66,6 @@ export type AgentChatComposerState = {
     pendingAttachments: ChatAttachment[];
     isUploading: boolean;
 };
-export type AgentToolActivityLine = {
-    activityId: string;
-    status: ChatToolActivityData['status'];
-    toolIcon: string;
-    statusIcon: string;
-    label: string;
-    detail: string;
-    note?: string;
-};
 type AgentChatControllerSettings = {
     sdk?: PageLinesSDK;
     agent: Agent | AgentConfig;
@@ -92,15 +84,22 @@ export declare class AgentChatController extends SettingsObject<AgentChatControl
     private lastMessage;
     private isConnecting;
     private activeTurnGeneration;
-    private toolActivityClock?;
-    private readonly toolActivityClockMs;
+    private boundaryTimer?;
+    private readonly nowMs;
     private readonly toolActivityTiming;
+    private readonly isStreamingText;
     private conversationId?;
     textState: Ref<TextConnectionState>;
     agentMode: Ref<AgentMode>;
     sharedMessages: Ref<ChatMessage[]>;
     readonly composerState: Ref<AgentChatComposerState>;
-    readonly toolActivityLines: ComputedRef<AgentToolActivityLine[]>;
+    /**
+     * The live line of work for the in-flight turn. Present only once the first
+     * activity arrives (before that, the top-level thinking cue owns the state —
+     * the two are mutually exclusive). Transient live work is always `running`;
+     * Task 7 owns `stopped`.
+     */
+    readonly workJournal: ComputedRef<WorkJournalModel | undefined>;
     readonly canUseComposer: ComputedRef<boolean>;
     readonly canAttachFile: ComputedRef<boolean>;
     readonly canRecordAudio: ComputedRef<boolean>;
@@ -151,18 +150,34 @@ export declare class AgentChatController extends SettingsObject<AgentChatControl
     private updateState;
     private resetToolActivityTiming;
     private resetState;
-    private startToolActivityClock;
-    private stopToolActivityClock;
-    private syncToolActivityClock;
+    /**
+     * Wake exactly once at the live journal's next slow/long boundary, recompute,
+     * and reschedule to the following one. When the boundary is undefined (turn
+     * finished, or already past the last boundary) the timer clears — so
+     * completion, cancellation, navigation, and teardown all stop it for free.
+     */
+    private setupBoundaryWatcher;
+    private scheduleBoundary;
+    private clearBoundaryTimer;
     private rememberToolActivity;
+    /**
+     * Backfill `startedAt`/`endedAt` when the wire omits them so the journal has
+     * stable timestamps for ordering, coalescing, and boundary scheduling. No
+     * duration is computed — elapsed time is never presented.
+     */
     private withToolActivityTiming;
     private updateToolActivity;
     private finishToolActivities;
-    toolActivityLinesFor(args: {
+    /**
+     * Project a persisted turn's activity into a durable work journal. The turn
+     * outcome is explicit — an assistant reply is `completed` (green terminal,
+     * even with a failed child), a system-error row is `failed`. Never inferred
+     * from child statuses.
+     */
+    workJournalFor(args: {
         activities?: ChatToolActivityData[];
-    }): AgentToolActivityLine[];
-    private toolActivityDetail;
-    private toolActivityElapsed;
+        outcome: WorkJournalOutcome;
+    }): WorkJournalModel | undefined;
     private setupModeWatcher;
     private setupAvailabilityWatcher;
     /**

package/dist/agent/index.d.ts

@@ -6,6 +6,7 @@ import { default as AgentWrap } from './ui/AgentWrap.vue';
 import { default as ElAgentChat } from './ui/ElAgentChat.vue';
 import { default as ElAgentChatPreview } from './ui/ElAgentChatPreview.vue';
 export { AgentChatController, AgentChatController as AgentController } from './AgentController';
-export type { AgentChatComposerState, AgentToolActivityLine, ChatStreamFn, ChatUploadFn } from './AgentController';
+export type { AgentChatComposerState, ChatStreamFn, ChatUploadFn } from './AgentController';
+export type { WorkJournalModel, WorkJournalOutcome, WorkJournalRow, WorkJournalTone } from './work-journal';
 export * from './schema';
 export { AgentChat, AgentModal, AgentProvider, AgentWidget, AgentWrap, ElAgentChat, ElAgentChatPreview };

package/dist/agent/schema.d.ts

@@ -31,6 +31,8 @@ export interface ChatMessage {
     conversationId?: string;
     sequence?: string;
     systemKind?: string | null;
+    /** Non-successful ending owned by the persisted assistant row. */
+    turnOutcome?: 'failed' | 'stopped';
     attachments?: ChatAttachment[];
     toolActivities?: ChatToolActivityData[];
     issue?: ChatMessageIssue;
@@ -51,6 +53,12 @@ export interface TextConnectionState {
      * Render as live chrome/details, never as transcript content.
      */
     toolActivities?: ChatToolActivityData[];
+    /**
+     * Keeps a non-successful live journal at the turn boundary. Cleared on the
+     * next send; persisted rows carry `failed` for salvaged partial replies and
+     * `stopped` for interruption, while system rows are failed by definition.
+     */
+    turnOutcome?: 'failed' | 'stopped';
     /**
      * Durable send block from a server issue that retrying cannot fix in this
      * session. Stays set until the controller is recreated or upstream state

package/dist/agent/ui/AgentToolActivityGroup.vue.d.ts

@@ -1,7 +1,7 @@
-import { AgentToolActivityLine } from '../AgentController';
+import { WorkJournalModel } from '../work-journal';
 type __VLS_Props = {
-    lines: AgentToolActivityLine[];
+    model: WorkJournalModel;
     isLight: boolean;
 };
-declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 export default _default;

package/dist/agent/ui/ChatScroller.vue.d.ts

@@ -8,7 +8,7 @@ declare function __VLS_template(): {
         viewport: HTMLDivElement;
         content: HTMLDivElement;
     };
-    rootEl: HTMLDivElement;
+    rootEl: any;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<{}, {
@@ -16,7 +16,7 @@ declare const __VLS_component: import('vue').DefineComponent<{}, {
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     viewport: HTMLDivElement;
     content: HTMLDivElement;
-}, HTMLDivElement>;
+}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

package/dist/agent/ui/ElAgentChat.vue.d.ts

@@ -32,7 +32,7 @@ declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {
         $parent: import('vue').ComponentPublicInstance | null;
         $host: Element | null;
         $emit: (event: string, ...args: any[]) => void;
-        $el: HTMLDivElement;
+        $el: any;
         $options: import('vue').ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
             pin: () => void;
         }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {

package/dist/agent/work-journal.d.ts

@@ -0,0 +1,68 @@
+import { ChatToolActivityData } from '@pagelines/core';
+/**
+ * The line of work — a pure projection of a turn's tool activity into one
+ * bounded work journal (plans/bots/bot-tool-calling.md § "One compact work
+ * journal"). Views render the result; they never decide lifecycle.
+ *
+ * `outcome` describes the TURN, never its children: a completed turn that
+ * contains a failed source still ends in the green `Work complete` terminal,
+ * with the failed source hanging inside the disclosure as a red station.
+ *
+ * The function is pure and takes `nowMs` — it never reads a clock. The clock
+ * only advances projection state (action → waiting label, then the leave
+ * hint); it never creates a milestone. Real completions create milestones;
+ * time may reveal the one transient wait tip after the slow boundary.
+ *
+ * `streamingText` marks that the assistant's reply is actively streaming under
+ * the journal (the Swift twin must mirror this rule). While it is true and the
+ * turn is running, the deltas ARE the progress: the wait tip and the leave hint
+ * are both suppressed, and only a genuinely in-flight tool keeps the active tip
+ * (milestones still render). Boundaries are still returned so the wait clock
+ * resumes the instant streaming stops.
+ */
+export type WorkJournalOutcome = 'running' | 'completed' | 'failed' | 'stopped';
+export type WorkJournalTone = 'done' | 'active' | 'failed' | 'stopped' | 'completed';
+export type WorkJournalRow = {
+    id: string;
+    tone: WorkJournalTone;
+    label: string;
+    note?: string;
+};
+export type WorkJournalModel = {
+    outcome: WorkJournalOutcome;
+    visibleRows: WorkJournalRow[];
+    hiddenRows: WorkJournalRow[];
+    terminal?: WorkJournalRow;
+    hint?: string;
+    nextBoundaryAtMs?: number;
+};
+/**
+ * The persisted row owns its turn's ending: an assistant reply is a completed
+ * turn (green terminal, even with a failed child), a system-error row is the
+ * failed turn, and an explicit `turnOutcome` marker owns salvaged failures
+ * and interruptions. Never inferred from child activity statuses.
+ */
+export declare function durableJournalOutcome(msg: {
+    sender: 'user' | 'agent' | 'system';
+    turnOutcome?: 'failed' | 'stopped';
+}): WorkJournalOutcome;
+/**
+ * Server composes activity labels; the client owns exactly these fixed
+ * strings (the single slow transition and the terminal/hint copy). Curly
+ * apostrophes and no em-dashes per std-writing / std-code-style.
+ */
+export declare const WORK_JOURNAL_COPY: {
+    readonly waiting: "Waiting for results";
+    readonly completed: "Work complete";
+    readonly failed: "Couldn’t finish";
+    readonly stopped: "Stopped";
+    readonly notifyHint: "Taking longer than usual. You can leave and I’ll notify you when it’s ready.";
+    readonly leaveHint: "You can leave this chat while I work.";
+};
+export declare function buildWorkJournalModel(args: {
+    activities: ChatToolActivityData[];
+    outcome: WorkJournalOutcome;
+    nowMs: number;
+    canNotifyOnCompletion: boolean;
+    streamingText?: boolean;
+}): WorkJournalModel;