editmamei 1.3.0 → 1.5.0

package/dist/perception/facets.js

@@ -41,7 +41,7 @@ export function estimateHorizon(rowMeans, docHeight, pick, mainSubjectBox, prima
     const split = pick.bright_fraction;
     const splitConfidence = Math.max(0, Math.min(1, 1 - Math.abs(0.5 - split) * 2)) * 0.6 + 0.2;
     if (!rowMeans || rowMeans.length === 0) {
-        return { y: Math.round(docHeight / 3), placement: 1 / 3, confidence: 0.2 };
+        return { detected: false, reason: 'no-row-profile' };
     }
     const R = rowMeans.length;
     let crossRow = -1;
@@ -52,14 +52,15 @@ export function estimateHorizon(rowMeans, docHeight, pick, mainSubjectBox, prima
         }
     }
     if (crossRow <= 0) {
-        return { y: Math.round(docHeight / 3), placement: 1 / 3, confidence: 0.2 };
+        return { detected: false, reason: 'no-luminance-crossing' };
     }
     const y = Math.round((crossRow / R) * docHeight);
     if ((mainSubjectBox && isDominantSubjectCrossing(y, docHeight, mainSubjectBox)) ||
         (primaryFaceBox && isPortraitFaceCrossing(y, docHeight, primaryFaceBox))) {
-        return { y: Math.round(docHeight / 3), placement: 1 / 3, confidence: 0.2 };
+        return { detected: false, reason: 'dominant-subject' };
     }
     return {
+        detected: true,
         y,
         placement: y / docHeight,
         confidence: Math.max(0, Math.min(1, splitConfidence)),

package/dist/perception/region-scorer.js

@@ -49,7 +49,7 @@ export function buildRegionSignals(info, scene) {
         centroidY = (bounds.top + bounds.bottom) / 2 / docH;
         touchesBottom = bounds.bottom >= docH * 0.97;
         touchesTop = bounds.top <= docH * 0.03;
-        if (scene.horizonConfidence > 0) {
+        if (scene.horizonConfidence > 0 && scene.horizonY !== null) {
             lowerEdgeAlign = 1 - Math.min(1, Math.abs(bounds.bottom - scene.horizonY) / docH);
             upperEdgeAlign = 1 - Math.min(1, Math.abs(bounds.top - scene.horizonY) / docH);
         }

package/dist/perception/scene-model.js

@@ -142,7 +142,7 @@ export async function buildSceneModel(connection, snippet, client, opts = {}) {
             recipe: { kind: 'posterize_region', levels: 3, sample: 'below_horizon' },
         },
     ];
-    const composition = computeComposition(mainBox, allBoxes, docW, docH, horizon.placement);
+    const composition = computeComposition(mainBox, allBoxes, docW, docH, horizon.detected ? horizon.placement : null);
     const backends = {
         faces: det.result.backends.faces,
         objects: det.result.backends.objects,

package/dist/perception/select-recipes.js

@@ -58,8 +58,8 @@ function sceneCtx(model) {
     return {
         docW: model.doc.width,
         docH: model.doc.height,
-        horizonY: model.horizon.y,
-        horizonConfidence: model.horizon.confidence,
+        horizonY: model.horizon.detected ? model.horizon.y : null,
+        horizonConfidence: model.horizon.detected ? model.horizon.confidence : 0,
         indoorObjectCount,
     };
 }
@@ -490,7 +490,18 @@ async function resolveFaceFeature(connection, snippet, target, feature, opts) {
     };
 }
 async function resolveAboveHorizon(connection, snippet, model, composition) {
-    const y = Math.max(1, Math.min(model.doc.height, model.horizon.y));
+    const horizon = model.horizon;
+    if (!horizon.detected) {
+        return {
+            target: 'above_horizon',
+            method: 'none',
+            passed: false,
+            confidence: 0,
+            reasons: [`no horizon was measured in this frame (${horizon.reason})`],
+            detail: { horizon_detected: false, horizon_reason: horizon.reason },
+        };
+    }
+    const y = Math.max(1, Math.min(model.doc.height, horizon.y));
     const result = (await runScript(connection, await snippet.build('selectRectangle', {
         left: 0,
         top: 0,

package/dist/platform/launch-readiness.js

@@ -0,0 +1,25 @@
+const DEFAULT_POLL_INTERVAL_MS = 250;
+export const LAUNCH_READY_MAX_WAIT_MS = 5_000;
+function defaultSleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms).unref();
+    });
+}
+export async function waitForLaunchReady(isReady, options = {}) {
+    const intervalMs = options.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const maxWaitMs = options.maxWaitMs ?? LAUNCH_READY_MAX_WAIT_MS;
+    const sleep = options.sleep ?? defaultSleep;
+    const isAborted = options.isAborted ?? (() => false);
+    const now = options.now ?? Date.now;
+    const deadline = now() + maxWaitMs;
+    while (now() < deadline) {
+        if (isAborted())
+            return false;
+        if (await isReady())
+            return true;
+        if (now() >= deadline)
+            break;
+        await sleep(intervalMs);
+    }
+    return false;
+}

package/dist/platform/macos-runner.js

@@ -2,12 +2,14 @@ import { exec, spawn } from 'child_process';
 import { promisify } from 'util';
 import { Logger } from '../utils/logger.js';
 import { TempDir } from '../utils/temp.js';
+import { DEFAULT_SCRIPT_TIMEOUT_MS } from '../utils/operation-timeouts.js';
 import { ScriptQueue } from './script-queue.js';
 import { runChildWithTimeout } from './run-child.js';
 import { decodeScriptResult } from './script-result.js';
+import { waitForLaunchReady } from './launch-readiness.js';
 const execAsync = promisify(exec);
-const DEFAULT_SCRIPT_TIMEOUT_MS = 30_000;
-const LAUNCH_GRACE_MS = 5_000;
+const LAUNCH_PROBE_TIMEOUT_MS = 2_000;
+const IS_RUNNING_EXEC_TIMEOUT_MS = 3_000;
 const UNSAFE_IN_APPLESCRIPT_LITERAL = /["\\\r\n\t]/;
 export class MacOSScriptRunner {
     logger = new Logger('MacOSScriptRunner');
@@ -69,7 +71,9 @@ end timeout`;
     }
     async isRunning() {
         try {
-            const { stdout } = await execAsync('pgrep -f "Adobe Photoshop"');
+            const { stdout } = await execAsync('pgrep -f "Adobe Photoshop"', {
+                timeout: IS_RUNNING_EXEC_TIMEOUT_MS,
+            });
             return stdout.trim().length > 0;
         }
         catch {
@@ -81,14 +85,20 @@ end timeout`;
             this.logger.info('Launching Photoshop', executablePath);
             const child = spawn('open', ['-a', executablePath], { detached: true, stdio: 'ignore' });
             child.unref();
-            const grace = setTimeout(() => {
-                grace.unref();
-                resolve();
-            }, LAUNCH_GRACE_MS);
+            let aborted = false;
             child.on('error', (error) => {
-                clearTimeout(grace);
+                aborted = true;
                 reject(new Error(`Could not launch Photoshop at ${executablePath}: ${error.message}`));
             });
+            const probe = () => this.run("'pong';", LAUNCH_PROBE_TIMEOUT_MS)
+                .then(() => true)
+                .catch(() => false);
+            waitForLaunchReady(probe, { isAborted: () => aborted })
+                .catch(() => false)
+                .then(() => {
+                if (!aborted)
+                    resolve();
+            });
         });
     }
 }

package/dist/platform/script-queue.js

@@ -8,23 +8,7 @@ export class ScriptQueue {
     }
     enqueue(run, timeout) {
         return new Promise((resolve, reject) => {
-            const task = {
-                run,
-                resolve,
-                reject,
-                cancelled: false,
-                settled: false,
-                timeoutId: null,
-            };
-            task.timeoutId = setTimeout(() => {
-                if (task.settled)
-                    return;
-                task.cancelled = true;
-                task.settled = true;
-                task.timeoutId = null;
-                reject(new Error('Script execution timeout'));
-            }, timeout + QUEUE_SLACK_MS);
-            this.queue.push(task);
+            this.queue.push({ run, timeout, resolve, reject, settled: false, timeoutId: null });
             void this.processQueue();
         });
     }
@@ -45,8 +29,10 @@ export class ScriptQueue {
         try {
             while (this.queue.length > 0) {
                 const task = this.queue.shift();
-                if (task.cancelled)
-                    continue;
+                task.timeoutId = setTimeout(() => {
+                    this.settleTask(task, () => task.reject(new Error('Script execution timeout')));
+                }, task.timeout + QUEUE_SLACK_MS);
+                task.timeoutId.unref?.();
                 try {
                     const result = await task.run();
                     this.settleTask(task, () => task.resolve(result));

package/dist/platform/windows-runner.js

@@ -2,12 +2,14 @@ import { exec, spawn } from 'child_process';
 import { promisify } from 'util';
 import { Logger } from '../utils/logger.js';
 import { TempDir } from '../utils/temp.js';
+import { DEFAULT_SCRIPT_TIMEOUT_MS } from '../utils/operation-timeouts.js';
 import { ScriptQueue } from './script-queue.js';
 import { runChildWithTimeout } from './run-child.js';
 import { decodeScriptResult } from './script-result.js';
+import { waitForLaunchReady } from './launch-readiness.js';
 const execAsync = promisify(exec);
-const DEFAULT_SCRIPT_TIMEOUT_MS = 30_000;
-const LAUNCH_GRACE_MS = 5_000;
+const LAUNCH_PROBE_TIMEOUT_MS = 2_000;
+const IS_RUNNING_EXEC_TIMEOUT_MS = 3_000;
 export class WindowsScriptRunner {
     logger = new Logger('WindowsScriptRunner');
     queue = new ScriptQueue(this.logger);
@@ -59,7 +61,9 @@ End If
     }
     async isRunning() {
         try {
-            const { stdout } = await execAsync('tasklist /FI "IMAGENAME eq Photoshop.exe"');
+            const { stdout } = await execAsync('tasklist /FI "IMAGENAME eq Photoshop.exe"', {
+                timeout: IS_RUNNING_EXEC_TIMEOUT_MS,
+            });
             return stdout.toLowerCase().includes('photoshop.exe');
         }
         catch {
@@ -71,14 +75,20 @@ End If
             this.logger.info('Launching Photoshop', executablePath);
             const child = spawn(executablePath, [], { detached: true, stdio: 'ignore' });
             child.unref();
-            const grace = setTimeout(() => {
-                grace.unref();
-                resolve();
-            }, LAUNCH_GRACE_MS);
+            let aborted = false;
             child.on('error', (error) => {
-                clearTimeout(grace);
+                aborted = true;
                 reject(new Error(`Could not launch Photoshop at ${executablePath}: ${error.message}`));
             });
+            const probe = () => this.run("'pong';", LAUNCH_PROBE_TIMEOUT_MS)
+                .then(() => true)
+                .catch(() => false);
+            waitForLaunchReady(probe, { isAborted: () => aborted })
+                .catch(() => false)
+                .then(() => {
+                if (!aborted)
+                    resolve();
+            });
         });
     }
 }

package/dist/telemetry/activity.js

@@ -0,0 +1,149 @@
+export const READ_ONLY_TOOLS = new Set([
+    'ps_sequence',
+    'ps_batch',
+    'ps_ping',
+    'ps_overview',
+    'ps_list_capabilities',
+    'ps_get_preview',
+    'ps_get_selection_preview',
+    'ps_get_histogram',
+    'ps_inspect',
+    'ps_read_scene',
+    'ps_compare_regions',
+    'ps_get_layer_bounds_diff',
+    'ps_template_list',
+    'ps_template_recall',
+    'ps_list_actions',
+    'ps_report_problem',
+    'ps_detect',
+    'ps_detect_landmarks',
+    'ps_document',
+    'ps_template_verify',
+    'ps_resolve_placement',
+    'ps_template_save',
+    'ps_template_delete',
+    'ps_template_create_evidence',
+]);
+export const KEPT_WORK_TOOLS = new Set(['ps_export', 'ps_save_psd']);
+export const MUTATING_TOOLS = new Set([
+    'ps_play_action',
+    'ps_execute_script',
+    'ps_add_adjustment_layer',
+    'ps_apply_adjustment',
+    'ps_create_document',
+    'ps_close_document',
+    'ps_open_document',
+    'ps_develop_raw',
+    'ps_filter',
+    'ps_group',
+    'ps_clipping_mask',
+    'ps_undo',
+    'ps_redo',
+    'ps_place_image',
+    'ps_resize_image',
+    'ps_crop_document',
+    'ps_convert_image_mode',
+    'ps_move_layer_to_position',
+    'ps_convert_to_smart_object',
+    'ps_rasterize_layer',
+    'ps_set_layer',
+    'ps_duplicate_layer',
+    'ps_copy_to_new_layer',
+    'ps_merge',
+    'ps_bake_layer',
+    'ps_add_layer_style',
+    'ps_create_layer',
+    'ps_delete_layer',
+    'ps_fill_layer',
+    'ps_add_fill_layer',
+    'ps_select_layer',
+    'ps_transform_layer',
+    'ps_warp_layer',
+    'ps_warp_layer_mesh',
+    'ps_warp_layer_along',
+    'ps_warp_layer_region',
+    'ps_warp_layer_to',
+    'ps_apply_camera_raw',
+    'ps_transform_canvas',
+    'ps_guides',
+    'ps_retouch',
+    'ps_apply_brush_stroke',
+    'ps_edit_object',
+    'ps_portrait_touchup',
+    'ps_add_text_to_object',
+    'ps_select_face_feature',
+    'ps_stroke_face_contour',
+    'ps_select_by_reference',
+    'ps_select',
+    'ps_select_subject',
+    'ps_select_sky',
+    'ps_select_subject_instance',
+    'ps_select_object',
+    'ps_replace_sky',
+    'ps_modify_selection',
+    'ps_selection_channel',
+    'ps_layer_mask',
+    'ps_path',
+    'ps_vector_mask',
+    'ps_apply_image',
+    'ps_calculations',
+    'ps_shape',
+    'ps_template_apply',
+    'ps_text',
+]);
+export function mapClientName(name) {
+    if (name === undefined)
+        return 'other';
+    const n = name.toLowerCase();
+    if (n.includes('claude-code') || n.includes('claude_code') || n.includes('claudecode')) {
+        return 'claude_code';
+    }
+    if (n.includes('claude'))
+        return 'claude_desktop';
+    if (n.includes('cursor'))
+        return 'cursor';
+    if (n.includes('windsurf'))
+        return 'windsurf';
+    if (n.includes('vscode') || n.includes('visual studio') || n.includes('code-oss')) {
+        return 'vscode';
+    }
+    return 'other';
+}
+export function parseMajor(version) {
+    if (version === undefined)
+        return null;
+    const m = /^(\d+)/.exec(version.trim());
+    return m ? Number(m[1]) : null;
+}
+export function boundMajor(n, max) {
+    return n !== null && Number.isFinite(n) && n >= 0 && n <= max ? n : null;
+}
+export function nodeMajor() {
+    return parseMajor(process.versions.node);
+}
+export function archToken() {
+    if (process.arch === 'x64')
+        return 'x64';
+    if (process.arch === 'arm64')
+        return 'arm64';
+    return 'other';
+}
+export function osMajor(platform, release) {
+    if (platform === 'win32') {
+        const parts = release.split('.');
+        const major = Number(parts[0]);
+        if (!Number.isFinite(major))
+            return null;
+        const build = Number(parts[2]);
+        return Number.isFinite(build) && build >= 22000 ? 11 : major;
+    }
+    if (platform === 'darwin') {
+        const m = /^(\d+)/.exec(release);
+        if (!m)
+            return null;
+        const darwinMajor = Number(m[1]);
+        return darwinMajor <= 24 ? darwinMajor - 9 : darwinMajor + 1;
+    }
+    const m = /^(\d+)/.exec(release);
+    return m ? Number(m[1]) : null;
+}

package/dist/telemetry/client.js

@@ -1,8 +1,10 @@
+import { release } from 'node:os';
 import { Logger } from '../utils/logger.js';
 import { EDITION } from '../edition.js';
 import { VERSION } from '../version.js';
 import { resolveInstallChannel } from '../install-channel.js';
-import { buildDiagnosticEvent, buildModuleStatus, buildSessionStart, buildSessionSummary, buildUsageEvent, dayBucket, isContentSafe, PS_VERSION_UNKNOWN, } from './events.js';
+import { READ_ONLY_TOOLS, KEPT_WORK_TOOLS, nodeMajor, archToken, osMajor, boundMajor, } from './activity.js';
+import { buildClientConnected, buildDiagnosticEvent, buildModuleStatus, buildSessionStart, buildSessionSummary, buildUsageEvent, dayBucket, normalizeDayBucket, isContentSafe, PS_VERSION_UNKNOWN, } from './events.js';
 import { sanitizeMessage, sanitizeSnippet, sanitizeStderrTail } from './sanitize.js';
 import { httpTransport, resolveEndpoint } from './transport.js';
 import { appendOutboxSync, clearOutbox, clearSessionState, readOutbox, readSessionState, writeSessionStateSync, } from './outbox.js';
@@ -10,6 +12,8 @@ const MAX_BATCH_SIZE = 100;
 const MAX_QUEUE_SIZE = 500;
 const DEFAULT_FLUSH_INTERVAL_MS = 5 * 60_000;
 const SESSION_PERSIST_THROTTLE_MS = 10_000;
+const MAX_SESSION_DURATION_S = 604_800;
+const MAX_INSTALL_ASSET_COUNT = 100_000;
 function isTestEnv() {
     return process.env.VITEST !== undefined || process.env.NODE_ENV === 'test';
 }
@@ -25,13 +29,25 @@ export class TelemetryClient {
     active;
     outboxOpts;
     getModuleStatus;
+    resolvedModuleStatus = null;
     queue = [];
     timer = null;
     shutdownPromise = null;
     toolCallCount = 0;
     distinctTools = new Set();
     anyFailures = false;
+    firstCallAtMs = null;
+    lastCallAtMs = null;
+    retryCount = 0;
+    lastCallSuccess = null;
+    editsOk = 0;
+    keptWork = 0;
+    droppedEvents = 0;
+    behindLatest = null;
+    moduleUpdate = 'none';
+    installAssets = {};
     lastSessionPersistMs = 0;
+    startDayBucket = null;
     constructor(opts) {
         this.settings = opts.settings;
         this.transport = opts.transport ?? httpTransport();
@@ -60,27 +76,104 @@ export class TelemetryClient {
         this.timer = setInterval(() => void this.flush(), this.flushIntervalMs);
         this.timer.unref?.();
         if (this.settings.telemetry.usage) {
-            this.enqueue(buildSessionStart(this.dims, this.now()));
-            const moduleStatus = this.getModuleStatus();
+            const hostNodeMajor = boundMajor(nodeMajor(), 999);
+            const hostOsMajor = boundMajor(osMajor(process.platform, release()), 999);
+            this.enqueue(buildSessionStart(this.dims, this.now(), {
+                ...(hostNodeMajor !== null ? { node_major: hostNodeMajor } : {}),
+                arch: archToken(),
+                ...(hostOsMajor !== null ? { os_major: hostOsMajor } : {}),
+            }));
+            const moduleStatus = this.moduleStatus();
             if (moduleStatus)
                 this.enqueue(buildModuleStatus(this.dims, moduleStatus, this.now()));
             void this.flush();
         }
     }
+    recordClientConnected(info) {
+        if (!this.active || !this.settings.telemetry.usage)
+            return;
+        this.enqueue(buildClientConnected(this.dims, info, this.now()));
+    }
     recordCall(call) {
         if (!this.active || !this.settings.telemetry.usage)
             return;
+        this.ensureStartDayBucket();
+        const nowDate = this.now();
+        const nowMs = nowDate.getTime();
         this.toolCallCount += 1;
         this.distinctTools.add(call.tool);
         if (!call.success)
             this.anyFailures = true;
-        this.enqueue(buildUsageEvent(this.dims, call, this.now()));
+        this.lastCallSuccess = call.success;
+        if (call.retry)
+            this.retryCount += 1;
+        if (call.success) {
+            if (!READ_ONLY_TOOLS.has(call.tool))
+                this.editsOk += 1;
+            if (KEPT_WORK_TOOLS.has(call.tool))
+                this.keptWork += 1;
+        }
+        if (this.firstCallAtMs === null)
+            this.firstCallAtMs = nowMs;
+        this.lastCallAtMs = nowMs;
+        this.enqueue(buildUsageEvent(this.dims, call, nowDate));
         this.persistSessionStateThrottled();
     }
+    setBehindLatest(value) {
+        this.behindLatest = value;
+    }
+    setModuleUpdate(outcome) {
+        this.moduleUpdate = outcome;
+    }
+    setInstallAssets(assets) {
+        const templatesSaved = assets.templates_saved !== undefined ? clampCount(assets.templates_saved) : null;
+        const actionSets = assets.action_sets !== undefined ? clampCount(assets.action_sets) : null;
+        this.installAssets = {
+            ...this.installAssets,
+            ...(templatesSaved !== null ? { templates_saved: templatesSaved } : {}),
+            ...(actionSets !== null ? { action_sets: actionSets } : {}),
+        };
+    }
+    moduleStatus() {
+        if (this.resolvedModuleStatus === null) {
+            this.resolvedModuleStatus = { value: this.getModuleStatus() };
+        }
+        return this.resolvedModuleStatus.value;
+    }
+    durationS() {
+        if (this.firstCallAtMs === null || this.lastCallAtMs === null)
+            return undefined;
+        return Math.min(Math.max(0, Math.floor((this.lastCallAtMs - this.firstCallAtMs) / 1000)), MAX_SESSION_DURATION_S);
+    }
+    summaryFields() {
+        const duration = this.durationS();
+        const moduleStatus = this.moduleStatus();
+        return {
+            ...(duration !== undefined ? { duration_s: duration } : {}),
+            retry_count: this.retryCount,
+            ...(this.lastCallSuccess !== null ? { ended_after_failure: !this.lastCallSuccess } : {}),
+            edits_ok: this.editsOk,
+            kept_work: this.keptWork,
+            ...(this.behindLatest !== null ? { behind_latest: this.behindLatest } : {}),
+            dropped_events: this.droppedEvents,
+            ...(moduleStatus !== null ? { module_update: this.moduleUpdate } : {}),
+            ...(this.installAssets.templates_saved !== undefined
+                ? { templates_saved: this.installAssets.templates_saved }
+                : {}),
+            ...(this.installAssets.action_sets !== undefined
+                ? { action_sets: this.installAssets.action_sets }
+                : {}),
+        };
+    }
     psVersion() {
         const v = this.dims.getPsVersion();
         return v && v.length > 0 ? v : PS_VERSION_UNKNOWN;
     }
+    ensureStartDayBucket() {
+        if (this.startDayBucket === null)
+            this.startDayBucket = dayBucket(this.now());
+        return this.startDayBucket;
+    }
     persistSessionStateThrottled() {
         const nowMs = this.now().getTime();
         if (this.lastSessionPersistMs !== 0 &&
@@ -90,7 +183,7 @@ export class TelemetryClient {
         this.lastSessionPersistMs = nowMs;
         const state = {
             install_id: this.dims.install_id,
-            ts_bucket: dayBucket(this.now()),
+            ts_bucket: this.ensureStartDayBucket(),
             editmamei_version: this.dims.editmamei_version,
             edition: this.dims.edition,
             platform: this.dims.platform,
@@ -98,6 +191,7 @@ export class TelemetryClient {
             tool_call_count: this.toolCallCount,
             distinct_tools: this.distinctTools.size,
             any_failures: this.anyFailures,
+            ...this.summaryFields(),
         };
         writeSessionStateSync(state, this.outboxOpts);
     }
@@ -116,6 +210,9 @@ export class TelemetryClient {
             error_message: sanitizeMessage(diag.error_message),
             ...(diag.snippet ? { snippet: sanitizeSnippet(diag.snippet) } : {}),
             ...(diag.stderr_tail ? { stderr_tail: sanitizeStderrTail(diag.stderr_tail) } : {}),
+            ...(diag.doc_depth !== undefined ? { doc_depth: diag.doc_depth } : {}),
+            ...(diag.doc_mode !== undefined ? { doc_mode: diag.doc_mode } : {}),
+            ...(diag.ps_locale !== undefined ? { ps_locale: diag.ps_locale } : {}),
         }, this.now()));
     }
     restampPsVersion(events) {
@@ -134,7 +231,9 @@ export class TelemetryClient {
     enqueue(event) {
         this.queue.push(event);
         if (this.queue.length > MAX_QUEUE_SIZE) {
-            this.queue.splice(0, this.queue.length - MAX_QUEUE_SIZE);
+            const excess = this.queue.length - MAX_QUEUE_SIZE;
+            this.queue.splice(0, excess);
+            this.droppedEvents += excess;
         }
         if (this.queue.length >= this.maxBatchSize)
             void this.flush();
@@ -170,7 +269,8 @@ export class TelemetryClient {
                 tool_call_count: this.toolCallCount,
                 distinct_tools: this.distinctTools.size,
                 any_failures: this.anyFailures,
-            }, this.now()));
+                ...this.summaryFields(),
+            }, this.ensureStartDayBucket(), this.now()));
         }
         if (this.queue.length > 0) {
             appendOutboxSync(this.restampPsVersion(this.queue.splice(0)).filter(isContentSafe), this.outboxOpts);
@@ -221,11 +321,13 @@ export class TelemetryClient {
     }
 }
 function summaryFromState(s) {
+    const templatesSaved = s.templates_saved !== undefined ? clampCount(s.templates_saved) : null;
+    const actionSets = s.action_sets !== undefined ? clampCount(s.action_sets) : null;
     return {
         v: 2,
         type: 'session_summary',
         install_id: s.install_id,
-        ts_bucket: s.ts_bucket,
+        ts_bucket: normalizeDayBucket(s.ts_bucket, new Date()),
         editmamei_version: s.editmamei_version,
         edition: s.edition,
         platform: s.platform,
@@ -233,8 +335,23 @@ function summaryFromState(s) {
         tool_call_count: s.tool_call_count,
         distinct_tools: s.distinct_tools,
         any_failures: s.any_failures,
+        ...(s.duration_s !== undefined ? { duration_s: s.duration_s } : {}),
+        ...(s.retry_count !== undefined ? { retry_count: s.retry_count } : {}),
+        ...(s.ended_after_failure !== undefined ? { ended_after_failure: s.ended_after_failure } : {}),
+        ...(s.edits_ok !== undefined ? { edits_ok: s.edits_ok } : {}),
+        ...(s.kept_work !== undefined ? { kept_work: s.kept_work } : {}),
+        ...(s.behind_latest !== undefined ? { behind_latest: s.behind_latest } : {}),
+        ...(s.dropped_events !== undefined ? { dropped_events: s.dropped_events } : {}),
+        ...(s.module_update !== undefined ? { module_update: s.module_update } : {}),
+        ...(templatesSaved !== null ? { templates_saved: templatesSaved } : {}),
+        ...(actionSets !== null ? { action_sets: actionSets } : {}),
     };
 }
 function errMsg(err) {
     return err instanceof Error ? err.message : String(err);
 }
+function clampCount(n) {
+    if (!Number.isFinite(n))
+        return null;
+    return Math.min(Math.max(0, Math.trunc(n)), MAX_INSTALL_ASSET_COUNT);
+}