dsh-ntr 0.1.4 → 0.1.6

package/lib/client/store.js

@@ -301,6 +301,7 @@ export class AcpStore {
         approvalRouted: false,
         chatSessions: [],
         tagHalo: { ...DEFAULT_TAG_HALO },
+        approvalDeadlines: undefined,
         chatTranscripts: {},
         acpMode: {},
         chatBoundAgent: {},
@@ -500,7 +501,7 @@ export class AcpStore {
     /** Snapshot refresh used on panel open and after a stream outage. */
     async resync() {
         try {
-            const [{ agents, approvalRouted }, { sessions }, defaultAgentInfo, detectResult, presetResult, tagHaloResult] = await Promise.all([
+            const [{ agents, approvalRouted }, { sessions }, defaultAgentInfo, detectResult, presetResult, tagHaloResult, deadlinesResult] = await Promise.all([
                 this.call('agents/list'),
                 this.call('sessions/list'),
                 // The plugin's OWN default ACP agent — a plugin-private id, not a DSH
@@ -511,6 +512,9 @@ export class AcpStore {
                 this.call('preset/status').catch(() => null),
                 // Host without the endpoint (older half) keeps the local default.
                 this.call('ui/tag-halo').catch(() => ({ halo: { ...DEFAULT_TAG_HALO } })),
+                // `undefined` (older half) hides the deadline card instead of showing a
+                // number this browser made up.
+                this.call('ui/approval-deadlines').catch(() => ({ deadlines: undefined })),
             ]);
             const detectedAgents = (detectResult && detectResult.agents.length > 0)
                 ? detectResult.agents
@@ -525,6 +529,7 @@ export class AcpStore {
                 approvalRouted: approvalRouted === true,
                 preset: presetResult?.preset ?? undefined,
                 tagHalo: tagHaloResult?.halo ?? { ...DEFAULT_TAG_HALO },
+                approvalDeadlines: deadlinesResult.deadlines,
             });
             const active = this.state.activeSessionId ?? sessions[0]?.sessionId;
             if (active !== undefined)
@@ -785,12 +790,23 @@ export class AcpStore {
     async loadTranscript(sessionId) {
         try {
             const { session, entries } = await this.call('transcript/get', { sessionId });
+            // An answer BEHIND what this page already folded must not replace it.
+            //
+            // The host fills its transcript from the notification pipeline, which the
+            // SDK paces independently of the `session/prompt` response, so a read
+            // taken right after a turn can still be missing the agent's last chunk.
+            // `lastSeq` already refuses to go backwards; the blocks must not either,
+            // or switching away and back inside that window truncates a turn the user
+            // just watched finish. A resumed session replays as fresh updates, but
+            // only after `session/reset` zeroes the watermark — so this cannot swallow
+            // a legitimate replay.
+            const seen = this.lastSeq.get(sessionId) ?? 0;
+            if ((entries.at(-1)?.seq ?? 0) < seen)
+                return;
             const blocks = [];
             for (const entry of entries) {
-                const before = blocks.length;
                 foldUpdate(blocks, entry.update);
                 this.lastSeq.set(sessionId, Math.max(this.lastSeq.get(sessionId) ?? 0, entry.seq));
-                void before;
             }
             const sessions = this.state.sessions.some(s => s.sessionId === sessionId)
                 ? this.state.sessions.map(s => (s.sessionId === sessionId ? session : s))
@@ -1276,6 +1292,54 @@ export class AcpStore {
             this.flashError(error);
         }
     }
+    /**
+     * Write the approval deadline (settings card), or drop the persisted override
+     * with `reset` so the `cordis.patch.yml` baseline applies again.
+     *
+     * The host answer — the same route returns the deadlines now in force — is the
+     * authority, so an optimistic write that the host trims (out of range, or
+     * merged with a value this browser did not know about) self-corrects instead
+     * of drifting from what runs.
+     */
+    async setApprovalDeadline(ms) {
+        await this.writeApprovalDeadlines({ permissionTimeoutMs: ms });
+    }
+    /**
+     * Write the mode: what an expired deadline DOES (`abort` refuses, `auto`
+     * answers with the option the agent's own kinds imply, `wait` never
+     * expires). Same write path as the window, so the host answer stays
+     * the authority.
+     */
+    async setApprovalTimeoutMode(mode) {
+        await this.writeApprovalDeadlines({ mode });
+    }
+    /** Drop the persisted override: the config file (or the built-in default) decides again. */
+    async resetApprovalDeadlines() {
+        await this.writeApprovalDeadlines({ reset: true });
+    }
+    async writeApprovalDeadlines(payload) {
+        const previous = this.state.approvalDeadlines;
+        // Optimistic only where it is safe: the effective numbers and the mode move
+        // now, and the override facts (`configured`) stay as the host last reported
+        // them. A failure restores the whole view.
+        if (previous !== undefined) {
+            this.mutate({
+                approvalDeadlines: {
+                    ...previous,
+                    ...(payload.permissionTimeoutMs === undefined ? {} : { permissionTimeoutMs: payload.permissionTimeoutMs }),
+                    ...(payload.mode === undefined ? {} : { mode: payload.mode }),
+                },
+            });
+        }
+        try {
+            const result = await this.call('ui/approval-deadlines-set', payload);
+            this.mutate({ approvalDeadlines: result.deadlines });
+        }
+        catch (error) {
+            this.mutate({ approvalDeadlines: previous });
+            this.flashError(error);
+        }
+    }
     /**
      * Bind one DSH chat session to an ACP agent. This is the plugin's own
      * conversation↔agent mapping: it does NOT write a DSH model route, so it
@@ -1554,6 +1618,16 @@ export class AcpStore {
                 this.mutate({ permissions: this.state.permissions.filter(p => p.requestId !== event.requestId) });
                 return Promise.resolve();
             }
+            case 'permission/synced': {
+                // Terminator of the reconnect replay: the host just re-sent every
+                // outstanding ask, and this set is the authoritative live list. Drop
+                // anything this client still holds from before the disconnect — an ask
+                // resolved while it was away is gone host-side, and answering it would
+                // only earn `unknown_request`.
+                const live = new Set(event.requestIds);
+                this.mutate({ permissions: this.state.permissions.filter(p => live.has(p.requestId)) });
+                return Promise.resolve();
+            }
             case 'chat/agent-locked': {
                 // The host locks a conversation at the START of its first ACP turn and
                 // says so at once; this frame is what makes the hand-off animation run