standout 0.5.28 → 0.5.30

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";
@@ -135,7 +136,9 @@ async function runAgent(jobId) {
     console.log("  │  are you really tokenmaxxing?  │");
     console.log("  │  Powered by Standout (YC P26)  │");
     console.log("  └────────────────────────────────┘\n");
-    if (jobId) {
+    // Only frame the token as a job in the application flow. Otherwise it may be a
+    // leaderboard group (`npx standout stanford`), confirmed after the wrapped runs.
+    if (jobId && profileChatEnabled()) {
         console.log(`  Applying to: ${STANDOUT_API_URL}/jobs/${jobId}\n`);
     }
     // LLM calls are proxied through Standout — users don't need an Anthropic key.
@@ -174,6 +177,7 @@ async function runAgent(jobId) {
             const wrapped = await createWrapped({
                 profile: prefetched,
                 submissionId: null,
+                group: jobId ?? null,
             });
             return { wrapped, prefetched };
         }
@@ -195,6 +199,9 @@ async function runAgent(jobId) {
     let wrappedId = wrapped?.id ?? null;
     if (wrapped) {
         await renderWrappedAll(wrapped.view);
+        if (wrapped.group) {
+            process.stderr.write(`  you're on the ${wrapped.group.label} leaderboard — see where you rank.\n\n`);
+        }
         await maybeShareWrapped(wrapped);
     }
     else {
@@ -326,6 +333,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/dist/wrapped-client.d.ts

@@ -1,10 +1,16 @@
 import type { WrappedAggregateView } from "./wrapped/types.js";
+export interface WrappedGroup {
+    slug: string;
+    label: string;
+}
 export interface WrappedReady {
     id: string;
     share_url: string;
     view: WrappedAggregateView;
+    group: WrappedGroup | null;
 }
 export declare function createWrapped(args: {
     profile: Record<string, unknown>;
     submissionId?: string | null;
+    group?: string | null;
 }): Promise<WrappedReady | null>;

package/dist/wrapped-client.js

@@ -97,6 +97,7 @@ export async function createWrapped(args) {
     const body = JSON.stringify({
         profile,
         submission_id: args.submissionId ?? undefined,
+        group: args.group ?? undefined,
     });
     const bodyKb = Math.round(bytesAfter / 1024);
     let created = null;
@@ -156,5 +157,10 @@ export async function createWrapped(args) {
         computed,
         share_url: created.share_url,
     });
-    return { id: created.id, share_url: created.share_url, view };
+    return {
+        id: created.id,
+        share_url: created.share_url,
+        view,
+        group: created.group ?? null,
+    };
 }

package/package.json

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