standout 0.5.28 → 0.5.29

package/dist/ai-usage.d.ts

@@ -99,7 +99,7 @@ export type RawStats = {
     sessions: Map<string, {
         firstTs: number;
         lastTs: number;
-        eventTimestamps: number[];
+        eventTimestamps: Set<number>;
         cwd: string | null;
         models: Set<string>;
         modelTurnCounts: Map<string, number>;

package/dist/ai-usage.js

@@ -305,13 +305,14 @@ function registerFile(raw, filePath) {
     raw.filePaths.add(filePath);
 }
 function recordSessionMeta(raw, sessionId, ts, cwd, model, version) {
+    const minute = Math.floor(ts / 60_000);
     const existing = raw.sessions.get(sessionId);
     if (existing) {
         if (ts < existing.firstTs)
             existing.firstTs = ts;
         if (ts > existing.lastTs)
             existing.lastTs = ts;
-        existing.eventTimestamps.push(ts);
+        existing.eventTimestamps.add(minute);
         if (!existing.cwd && cwd)
             existing.cwd = cwd;
         if (model)
@@ -323,7 +324,7 @@ function recordSessionMeta(raw, sessionId, ts, cwd, model, version) {
         raw.sessions.set(sessionId, {
             firstTs: ts,
             lastTs: ts,
-            eventTimestamps: [ts],
+            eventTimestamps: new Set([minute]),
             cwd,
             models: model ? new Set([model]) : new Set(),
             modelTurnCounts: new Map(),
@@ -804,10 +805,11 @@ export function computeStreaks(activeDays) {
         current = 0;
     return { longest, current };
 }
-function estimateActiveDurationMs(timestamps) {
-    const sorted = [...new Set(timestamps)]
-        .filter((ts) => Number.isFinite(ts))
-        .sort((a, b) => a - b);
+function estimateActiveDurationMs(minuteBuckets) {
+    const sorted = [...new Set(minuteBuckets)]
+        .filter((m) => Number.isFinite(m))
+        .sort((a, b) => a - b)
+        .map((m) => m * 60_000);
     if (sorted.length === 0)
         return 0;
     if (sorted.length === 1)
@@ -840,10 +842,11 @@ function compactCwd(cwd) {
 }
 // Split a session's events into active segments (consecutive events <= 15min
 // apart), so concurrency reflects real work, not a tab idle for days.
-function activeSegments(timestamps) {
-    const sorted = [...new Set(timestamps)]
-        .filter((t) => Number.isFinite(t))
-        .sort((a, b) => a - b);
+function activeSegments(minuteBuckets) {
+    const sorted = [...new Set(minuteBuckets)]
+        .filter((m) => Number.isFinite(m))
+        .sort((a, b) => a - b)
+        .map((m) => m * 60_000);
     if (sorted.length === 0)
         return [];
     const maxGapMs = MAX_ACTIVE_GAP_MINUTES * 60 * 1000;

package/dist/cli.js

@@ -4,6 +4,7 @@ import chalk from "chalk";
 import { createInterface } from "readline";
 import { markWrappedShared, STANDOUT_API_URL } from "./api.js";
 import { gatherFullEnrichment, gatherProfileBasics, gatherUsageStats, } from "./gather.js";
+import { ensureHeapHeadroom } from "./heap.js";
 import { startMcpServer } from "./mcp.js";
 import { configureProxyFromEnv } from "./proxy.js";
 import { SYSTEM_PROMPT } from "./prompt.js";
@@ -326,6 +327,7 @@ async function runAgent(jobId) {
     console.log(`  Tokens: ${totalInputTokens.toLocaleString()} in / ${totalOutputTokens.toLocaleString()} out${cacheNote} in ${elapsed}s\n`);
 }
 async function main() {
+    ensureHeapHeadroom();
     const args = process.argv.slice(2);
     // Route fetch through a configured proxy before any network call — Node's fetch
     // ignores HTTP(S)_PROXY otherwise, which breaks users behind a corporate proxy.

package/dist/heap.d.ts

@@ -0,0 +1 @@
+export declare function ensureHeapHeadroom(): void;

package/dist/heap.js

@@ -0,0 +1,25 @@
+import { spawnSync } from "child_process";
+import { totalmem } from "os";
+// Node caps old-space at ~4GB by default regardless of physical RAM, so a big
+// machine OOMs at the same point as a small one. On machines with headroom,
+// re-exec once with a higher --max-old-space-size (half of RAM, capped at 8GB)
+// so heavy log archives have room. The real bound is algorithmic (see
+// ai-usage.ts); this is just a safety net.
+export function ensureHeapHeadroom() {
+    if (process.env.STANDOUT_HEAP_BOOSTED === "1")
+        return;
+    if (process.execArgv.some((a) => a.startsWith("--max-old-space-size")))
+        return;
+    const totalMb = Math.floor(totalmem() / (1024 * 1024));
+    const desiredMb = Math.min(8192, Math.floor(totalMb / 2));
+    if (desiredMb <= 4096)
+        return;
+    const entry = process.argv[1];
+    if (!entry)
+        return;
+    const res = spawnSync(process.execPath, [`--max-old-space-size=${desiredMb}`, entry, ...process.argv.slice(2)], {
+        stdio: "inherit",
+        env: { ...process.env, STANDOUT_HEAP_BOOSTED: "1" },
+    });
+    process.exit(res.status ?? 0);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "standout",
-  "version": "0.5.28",
+  "version": "0.5.29",
   "description": "Build your developer profile with AI. One command, zero friction.",
   "type": "module",
   "main": "./dist/cli.js",