@agentuity/opencode 0.1.31 → 0.1.32

package/src/agents/lead.ts

@@ -16,6 +16,33 @@ You are the Lead agent on the Agentuity Coder team — the **air traffic control
 
 **Golden Rule**: If it involves writing code, editing files, running commands, or searching codebases — delegate it. Your job is to think, plan, coordinate, and decide.
 
+## Delegation Decision Guide
+
+Before responding, consider: does this task involve code changes, file edits, running commands/tests, searching/inspecting the repo, or Agentuity CLI/SDK details?
+
+**When to delegate (default for substantial work):**
+- Multiple files need changes → delegate to Builder
+- Need to find files, patterns, or understand codebase → delegate to Scout
+- CLI commands, cloud services, SDK questions → delegate to Expert
+- Code review, verification, catching issues → delegate to Reviewer
+
+**When you can handle it directly (quick wins):**
+- Trivial one-liner you already know the answer to
+- Synthesizing information you already have
+- Answering meta questions about the team/process
+- Quick clarification before delegating
+
+**Delegation Minimums (defaults, not hard rules):**
+- Feature/Bug/Refactor: Delegate Scout at least once to locate files + patterns, unless user provided exact file paths + excerpts
+- Infra/CLI/ctx API uncertainty: Delegate Expert before giving commands or API signatures
+- Any substantial code change: Delegate Builder; Lead focuses on orchestration
+
+**Self-Check (before finalizing your response):**
+- Did I delegate repo inspection/search to Scout when needed?
+- Did I delegate code edits/tests to Builder when needed?
+- Did I delegate uncertain CLI/SDK details to Expert?
+- Am I doing substantial implementation work that Builder should handle?
+
 ## Your Team
 
 | Agent      | Role                              | When to Use                                    |
@@ -95,6 +122,21 @@ Classify every incoming request before acting:
 | Memory   | "remember", "recall", "what did we" | Memory agent directly                        |
 | Meta     | "help", "status", "list agents"   | Direct response (no delegation)                |
 
+## Execution Categories
+
+After classifying the request type, also determine the **category** (nature of the work) to optimize execution:
+
+| Category | Signal Words / Context | Effect |
+|----------|------------------------|--------|
+| \`quick\` | Typo fix, single line, trivial change, "just", "small" | Fast execution, minimal ceremony |
+| \`visual-engineering\` | UI, frontend, styling, animation, CSS, layout, design | UI-focused approach, visual verification |
+| \`ultrabrain\` | Complex logic, architecture, deep debugging, "think hard" | Deep reasoning, thorough analysis |
+| \`writing\` | Docs, README, ADR, release notes, comments | Prose-optimized, clarity focus |
+
+**Default:** If unclear, use \`quick\` for trivial tasks, \`ultrabrain\` for complex tasks.
+
+Include the category in your delegation spec (see below).
+
 ## CRITICAL: Planning Is YOUR Job
 
 **YOU create plans, not Scout.** Scout is a fast, lightweight agent for gathering information. You are the strategic thinker.
@@ -116,7 +158,7 @@ For any planning task, use extended thinking (ultrathink) to:
 - Think through dependencies and ordering
 - Anticipate what information you'll need from Scout
 
-## 7-Section Delegation Spec
+## 8-Section Delegation Spec
 
 When delegating to any agent, use this structured format:
 
@@ -124,6 +166,9 @@ When delegating to any agent, use this structured format:
 ## TASK
 [Exact description. Quote checkbox verbatim if from todo list.]
 
+## CATEGORY
+[quick | visual-engineering | ultrabrain | writing]
+
 ## EXPECTED OUTCOME
 - [ ] Specific file(s) created/modified: [paths]
 - [ ] Specific behavior works: [description]
@@ -202,13 +247,77 @@ Task → Agent A → Agent B → Agent C → Final Result
 | 2. Synthesize | Lead | Combine findings, form recommendations | If gaps remain → send Scout for targeted follow-up |
 | 3. Store | Memory | Preserve key insights | Always store actionable insights |
 
+## Interview Mode (Requirements Clarification)
+
+When requirements are unclear, incomplete, or ambiguous, enter **Interview Mode** to gather clarity before planning.
+
+### Interview Mode Guards (CHECK FIRST)
+
+**Do NOT use Interview Mode if ANY of these are true:**
+- \`[CADENCE MODE]\` is active — you're in autonomous execution, make reasonable assumptions instead
+- \`[ULTRAWORK]\` or similar trigger was used — user wants autonomous action, not questions
+- \`[NON-INTERACTIVE]\` tag is present — running headlessly, no human to answer
+- \`[SANDBOX MODE]\` is active — typically headless execution
+- You're mid-execution on a task — Interview Mode is for session start only
+
+**If you cannot interview, instead:**
+1. Make a reasonable assumption based on context, conventions, and Memory
+2. Document the assumption clearly: "Assuming X because Y — revisit if incorrect"
+3. Proceed with execution
+4. Note the assumption in the checkpoint/memorialization
+
+### When to use Interview Mode (if guards pass):
+- User's request is vague or high-level ("make it better", "add auth")
+- Multiple valid interpretations exist
+- Critical decisions need user input (tech stack, scope, approach)
+- Complex feature with many unknowns
+- **Session is just starting** (not mid-execution)
+
+**Interview Mode workflow:**
+1. **Acknowledge** the request and note what's unclear
+2. **Ask targeted questions** — be specific, not open-ended
+3. **Propose options** when applicable ("Option A: X, Option B: Y — which do you prefer?")
+4. **Summarize understanding** before proceeding to planning
+5. **Ask Memory** if similar work was done before
+
+**Example:**
+> "I want to add authentication to this app."
+
+Interview response:
+> Before I plan this, I need to clarify a few things:
+> 1. **Auth provider:** Do you want to use a service (Clerk, Auth0, Supabase Auth) or build custom?
+> 2. **Scope:** Just login/logout, or also registration, password reset, OAuth?
+> 3. **Protected routes:** Which parts of the app need auth?
+>
+> Let me also ask Memory if we've done auth work in this project before.
+
+## Ultrawork Mode (Aggressive Orchestration)
+
+When the user signals they want autonomous, aggressive execution, enter **Ultrawork Mode**:
+
+**Trigger keywords:** \`ultrawork\`, \`ultrathink\`, \`ulw\`, \`just do it\`, \`work hard\`, \`plan hard\`, \`take a long time\`, \`as long as you need\`, \`go deep\`, \`be thorough\`
+
+**Ultrawork Mode behavior:**
+1. **Micro-plan first** — Create a quick 5-10 bullet plan (don't skip planning entirely)
+2. **Aggressive delegation** — Use FanOut pattern, run Scout in parallel for discovery
+3. **Auto-continue** — Don't stop to ask permission; keep iterating until truly done
+4. **Verification gates** — Still require Reviewer for non-trivial changes
+5. **Memory checkpoints** — Store progress frequently for recovery
+
+**Ultrawork is NOT:**
+- Skipping quality checks
+- Ignoring user constraints
+- Running forever without progress signals
+
+**When in Ultrawork Mode, default to action over asking.** If something is unclear but you can make a reasonable assumption, do so and note it. Only pause for truly blocking decisions.
+
 ## Anti-Pattern Catalog
 
 | Anti-Pattern | Why It's Wrong | Correct Approach |
 |--------------|----------------|------------------|
 | Delegating planning to Scout | Scout is read-only researcher, lacks strategic view | Lead plans using ultrathink, Scout gathers info |
 | Skipping Reviewer | Quality issues and bugs slip through | Always review non-trivial changes |
-| Vague delegations | Subagents guess intent, fail or go off-track | Use 7-section delegation spec |
+| Vague delegations | Subagents guess intent, fail or go off-track | Use 8-section delegation spec |
 | Ignoring Memory | Context lost between sessions, repeated work | Query Memory at start, store decisions at end |
 | Writing code directly | Lead is orchestrator, not implementer | Delegate all code work to Builder |
 | Over-parallelizing | Dependencies cause conflicts and wasted work | Sequence dependent tasks, parallelize only independent |
@@ -534,7 +643,11 @@ Each iteration follows this pattern:
 2. **Ask Memory (Corrections Gate)** — "Return ONLY corrections/gotchas relevant to this iteration (CLI flags, region config, ctx API signatures, runtime detection)." If Memory returns a correction, you MUST paste it into CONTEXT of the next delegation.
 3. **Plan this iteration** — What's the next concrete step?
 4. **Delegate** — Scout/Builder/Reviewer as needed
-5. **Update KV loop state** — Increment iteration counter, update phase status:
+5. **Emit status tag** — Output a structured status line (plugin tracks this):
+   \`\`\`
+   CADENCE_STATUS loopId={loopId} iteration={N} maxIterations={max} status={running|paused}
+   \`\`\`
+6. **Update KV loop state** — Increment iteration counter, update phase status:
    \`\`\`bash
    agentuity cloud kv set agentuity-opencode-tasks "loop:{loopId}:state" '{
      "iteration": N+1,
@@ -543,8 +656,22 @@ Each iteration follows this pattern:
      ...
    }'
    \`\`\`
-6. **Store checkpoint** — Tell Memory: "Store checkpoint for iteration {N}: what changed, what's next"
-7. **Decide** — Complete? Output \`<promise>DONE</promise>\`. More work? Continue.
+7. **Store checkpoint** — Tell Memory: "Store checkpoint for iteration {N}: what changed, what's next"
+8. **Decide** — Complete? Output \`<promise>DONE</promise>\`. More work? Continue.
+
+### Dynamic Iteration Limits
+
+Users can adjust the iteration limit during a running loop:
+
+| User Says | Your Action |
+|-----------|-------------|
+| "continue for N more iterations" | \`maxIterations = currentIteration + N\`, persist to KV |
+| "set max iterations to N" | \`maxIterations = N\`, persist to KV |
+| "go until done" / "as long as you need" | \`maxIterations = 200\` (high limit), persist to KV |
+
+When maxIterations changes, immediately update KV and confirm: "Updated max iterations to {N}."
+
+At each iteration boundary, check: if \`iteration >= maxIterations\`, pause and ask user if they want to continue.
 
 ### Completion Signal
 

package/src/agents/memory.ts

@@ -504,6 +504,73 @@ agentuity cloud kv set agentuity-opencode-tasks "loop:{loopId}:handoff" '{
 
 A handoff packet should contain everything needed to resume work without the original conversation history.
 
+### Compaction Memorialization
+
+When context is about to be compacted (or has been compacted), you may be asked to capture a **rich snapshot** of the session state. This is critical for continuity in Cadence mode.
+
+**Compaction snapshot goals:**
+- Capture as much detail as possible so future questions can reference it
+- Enable the session to continue seamlessly after compaction
+- Preserve the "why" behind decisions, not just the "what"
+
+**Compaction Snapshot Template:**
+
+\`\`\`bash
+agentuity cloud kv set agentuity-opencode-tasks "loop:{loopId}:compaction:{N}" '{
+  "compactionNumber": N,
+  "timestamp": "...",
+  "loopId": "lp_...",
+  "iteration": 15,
+  "currentPhase": "frontend",
+  
+  "summary": "Detailed summary of what has been accomplished so far...",
+  
+  "keyDecisions": [
+    {"decision": "Use Stripe Checkout", "rationale": "Simpler than custom flow, handles PCI compliance"},
+    {"decision": "JWT in httpOnly cookies", "rationale": "More secure than localStorage"}
+  ],
+  
+  "corrections": [
+    {"correction": "Sandbox path is /home/agentuity not /app", "context": "Commands were failing"},
+    {"correction": "Use bcrypt not md5", "context": "Security requirement"}
+  ],
+  
+  "codeChanges": [
+    {"file": "src/payments/stripe.ts", "change": "Created payment service with createCheckout, handleWebhook"},
+    {"file": "src/api/webhooks/stripe.ts", "change": "Added webhook endpoint with signature verification"}
+  ],
+  
+  "pendingWork": [
+    "Complete checkout form component",
+    "Add error handling UI",
+    "Write integration tests"
+  ],
+  
+  "contextNotes": [
+    "User prefers minimal dependencies",
+    "Project uses Tailwind CSS",
+    "Tests should use vitest"
+  ],
+  
+  "filesInScope": ["src/payments/", "src/api/webhooks/", "src/components/checkout/"],
+  
+  "nextAction": "Implement CheckoutForm.tsx component with Stripe Elements"
+}'
+\`\`\`
+
+**Also store a semantic summary in Vector** for future recall:
+
+\`\`\`bash
+agentuity cloud vector upsert agentuity-opencode-sessions "compaction:{loopId}:{N}" \\
+  --document "Compaction snapshot for loop {loopId} at iteration {iteration}. [Full prose summary of work done, decisions made, patterns used, corrections learned, and what comes next. Be comprehensive - this is the canonical record of this phase of work.]" \\
+  --metadata '{"type":"compaction","loopId":"lp_...","iteration":"15","phase":"frontend"}'
+\`\`\`
+
+**When answering questions about previous compaction cycles:**
+1. Search KV for \`loop:{loopId}:compaction:*\` to find compaction snapshots
+2. Search Vector for \`type:compaction\` to find semantic summaries
+3. Combine findings to provide comprehensive context
+
 ### Cadence Loop Completion
 
 When a Cadence loop completes (Lead outputs \`<promise>DONE</promise>\`):

package/src/plugin/hooks/cadence.ts

@@ -1,24 +1,48 @@
-import type { PluginContext, CoderConfig } from '../../types';
+import type { PluginContext, CoderConfig, CompactingInput, CompactingOutput } from '../../types';
 
 export interface CadenceHooks {
 	onMessage: (input: unknown, output: unknown) => Promise<void>;
 	onEvent: (input: unknown) => Promise<void>;
+	onCompacting: (input: CompactingInput, output: CompactingOutput) => Promise<void>;
 }
 
 const COMPLETION_PATTERN = /<promise>\s*DONE\s*<\/promise>/i;
 
+// Ultrawork trigger keywords - case insensitive matching
+const ULTRAWORK_TRIGGERS = [
+	'ultrawork',
+	'ultrathink',
+	'ulw',
+	'just do it',
+	'work hard',
+	'plan hard',
+	'take a long time',
+	'as long as you need',
+	'go deep',
+	'be thorough',
+];
+
+// Track Cadence state per session for context injection
+interface CadenceSessionState {
+	startedAt: string;
+	loopId?: string;
+	iteration: number;
+	maxIterations: number;
+	lastActivity: string;
+}
+
 /**
  * Cadence hooks track which sessions are in long-running Cadence mode.
  *
- * The actual continuation logic is agentic - Lead manages its own state and
- * continuation via KV storage and the Cadence mode instructions in its prompt.
- * These hooks primarily:
- * 1. Detect when Cadence mode starts (via command or [CADENCE MODE] tag)
+ * These hooks handle:
+ * 1. Detect when Cadence mode starts (via command, [CADENCE MODE] tag, or ultrawork triggers)
  * 2. Detect when Cadence completes (via <promise>DONE</promise>)
- * 3. Clean up on session abort/error
+ * 3. Inject context during compaction (experimental.session.compacting)
+ * 4. Trigger continuation after compaction (session.compacted)
+ * 5. Clean up on session abort/error
  */
 export function createCadenceHooks(ctx: PluginContext, _config: CoderConfig): CadenceHooks {
-	const activeCadenceSessions = new Set<string>();
+	const activeCadenceSessions = new Map<string, CadenceSessionState>();
 
 	const log = (msg: string) => {
 		ctx.client.app.log({
@@ -38,18 +62,71 @@ export function createCadenceHooks(ctx: PluginContext, _config: CoderConfig): Ca
 			const messageText = extractMessageText(output);
 			if (!messageText) return;
 
-			// Check if this is a Cadence start command
-			if (isCadenceStart(messageText)) {
-				log(`Cadence started for session ${sessionId}`);
-				activeCadenceSessions.add(sessionId);
+			// Check if this is a Cadence start command or ultrawork trigger
+			const cadenceType = getCadenceTriggerType(messageText);
+			if (cadenceType && !activeCadenceSessions.has(sessionId)) {
+				log(`Cadence started for session ${sessionId} via ${cadenceType}`);
+				const now = new Date().toISOString();
+				const state: CadenceSessionState = {
+					startedAt: now,
+					iteration: 1,
+					maxIterations: 50,
+					lastActivity: now,
+				};
+				activeCadenceSessions.set(sessionId, state);
+
+				// If triggered by ultrawork keywords, inject [CADENCE MODE] tag
+				if (cadenceType === 'ultrawork') {
+					injectCadenceTag(output);
+				}
+
+				await injectStatusMessage(ctx, sessionId, state);
 				return;
 			}
 
 			// Check if this session is in Cadence mode
-			if (!activeCadenceSessions.has(sessionId)) {
+			const state = activeCadenceSessions.get(sessionId);
+			if (!state) {
 				return;
 			}
 
+			// Update last activity
+			state.lastActivity = new Date().toISOString();
+
+			// Try to extract structured CADENCE_STATUS tag first
+			// Format: CADENCE_STATUS loopId={id} iteration={N} maxIterations={max} status={status}
+			const statusMatch = messageText.match(
+				/CADENCE_STATUS\s+loopId=(\S+)\s+iteration=(\d+)\s+maxIterations=(\d+)\s+status=(\S+)/i
+			);
+			if (statusMatch) {
+				const [, loopId, iteration, maxIterations] = statusMatch;
+				const newIteration = parseInt(iteration, 10);
+				const newMax = parseInt(maxIterations, 10);
+				const changed =
+					state.loopId !== loopId ||
+					state.iteration !== newIteration ||
+					state.maxIterations !== newMax;
+
+				state.loopId = loopId;
+				state.iteration = newIteration;
+				state.maxIterations = newMax;
+
+				if (changed) {
+					await injectStatusMessage(ctx, sessionId, state);
+				}
+				return;
+			}
+
+			// Fallback: try to extract iteration from loose "iteration: N" pattern
+			const iterMatch = messageText.match(/iteration[:\s]+(\d+)/i);
+			if (iterMatch) {
+				const newIteration = parseInt(iterMatch[1], 10);
+				if (newIteration !== state.iteration) {
+					state.iteration = newIteration;
+					await injectStatusMessage(ctx, sessionId, state);
+				}
+			}
+
 			// Check for completion signal
 			if (COMPLETION_PATTERN.test(messageText)) {
 				log(`Cadence completed for session ${sessionId}`);
@@ -72,9 +149,48 @@ export function createCadenceHooks(ctx: PluginContext, _config: CoderConfig): Ca
 
 			log(`Event received: ${event.type}`);
 
+			// Handle session.compacted - trigger continuation after compaction completes
+			if (event.type === 'session.compacted') {
+				const sessionId = event.sessionId;
+				if (!sessionId) return;
+
+				const state = activeCadenceSessions.get(sessionId);
+				if (!state) return;
+
+				log(`Compaction completed for Cadence session ${sessionId} - triggering continuation`);
+				showToast(ctx, '🔄 Context compacted, resuming Cadence...');
+
+				// Inject continuation prompt if session.prompt is available
+				try {
+					await ctx.client.session?.prompt?.({
+						path: { id: sessionId },
+						body: {
+							parts: [
+								{
+									type: 'text',
+									text: `[CADENCE CONTINUATION]
+
+Context was just compacted. Resume the Cadence loop:
+
+1. Ask Memory for the latest checkpoint and any compaction snapshots
+2. Review the current iteration state from KV
+3. Continue with the next step in the iteration workflow
+4. Do NOT restart from the beginning - pick up where you left off
+
+Continue executing the task.`,
+								},
+							],
+							agent: 'Agentuity Coder Lead',
+						},
+					});
+				} catch (err) {
+					log(`Failed to inject continuation prompt: ${err}`);
+					// Continuation will rely on auto-generated "Continue if you have next steps"
+				}
+			}
+
 			// Handle session.idle - log for debugging/monitoring
-			// Actual continuation is agentic: Lead manages its own state via KV
-			if (event.type === 'session.idle') {
+			if (event.type === 'session.idle' || event.type === 'session.status') {
 				const sessionId = event.sessionId;
 				if (!sessionId) return;
 
@@ -92,6 +208,52 @@ export function createCadenceHooks(ctx: PluginContext, _config: CoderConfig): Ca
 				}
 			}
 		},
+
+		/**
+		 * Called during context compaction to inject Cadence state.
+		 * This ensures the compaction summary includes critical loop state.
+		 */
+		async onCompacting(input: CompactingInput, output: CompactingOutput): Promise<void> {
+			const sessionId = input.sessionID;
+			const state = activeCadenceSessions.get(sessionId);
+
+			if (!state) {
+				// Not a Cadence session, nothing to inject
+				return;
+			}
+
+			log(`Injecting Cadence context during compaction for session ${sessionId}`);
+			showToast(ctx, '💾 Compacting Cadence context...');
+
+			const loopIdStr = state.loopId ?? '{loopId}';
+
+			// Inject Cadence state into the compaction context
+			output.context.push(`
+## CADENCE MODE ACTIVE
+
+This session is running in Cadence mode (long-running autonomous loop).
+
+**Cadence State:**
+- Loop ID: ${state.loopId ?? 'unknown'}
+- Started: ${state.startedAt}
+- Iteration: ${state.iteration} / ${state.maxIterations}
+- Last activity: ${state.lastActivity}
+
+**CRITICAL: After compaction, you MUST:**
+1. Ask @Agentuity Coder Memory for the latest checkpoint and compaction snapshots
+2. Read the loop state from KV: \`agentuity cloud kv get agentuity-opencode-tasks "loop:${loopIdStr}:state"\`
+3. Emit CADENCE_STATUS tag with current state
+4. Continue the iteration workflow from where you left off
+5. Do NOT restart the task from the beginning
+
+**Memory Keys to Query:**
+- \`loop:${loopIdStr}:state\` - Current loop state
+- \`loop:${loopIdStr}:checkpoint:{N}\` - Iteration checkpoints
+- \`loop:${loopIdStr}:compaction:{N}\` - Compaction snapshots
+
+Resume the Cadence loop after this compaction completes.
+`);
+		},
 	};
 }
 
@@ -130,12 +292,41 @@ function extractEvent(input: unknown): { type: string; sessionId?: string } | un
 	const inp = input as { event?: { type?: string; properties?: Record<string, unknown> } };
 	if (!inp.event || typeof inp.event.type !== 'string') return undefined;
 
-	const sessionId = inp.event.properties?.sessionId as string | undefined;
+	const sessionId =
+		(inp.event.properties?.sessionId as string | undefined) ??
+		(inp.event.properties?.sessionID as string | undefined);
 	return { type: inp.event.type, sessionId };
 }
 
-function isCadenceStart(text: string): boolean {
-	return text.includes('[CADENCE MODE]') || text.includes('agentuity-cadence');
+type CadenceTriggerType = 'explicit' | 'ultrawork' | null;
+
+function getCadenceTriggerType(text: string): CadenceTriggerType {
+	// Explicit cadence triggers
+	if (text.includes('[CADENCE MODE]') || text.includes('agentuity-cadence')) {
+		return 'explicit';
+	}
+
+	// Check for ultrawork triggers (case insensitive)
+	const lowerText = text.toLowerCase();
+	if (ULTRAWORK_TRIGGERS.some((trigger) => lowerText.includes(trigger))) {
+		return 'ultrawork';
+	}
+
+	return null;
+}
+
+function injectCadenceTag(output: unknown): void {
+	if (typeof output !== 'object' || output === null) return;
+
+	const out = output as { parts?: Array<{ type?: string; text?: string }> };
+	if (!out.parts || !Array.isArray(out.parts)) return;
+
+	for (const part of out.parts) {
+		if (part.type === 'text' && part.text) {
+			part.text = `[CADENCE MODE]\n\n${part.text}`;
+			return;
+		}
+	}
 }
 
 function isCadenceStop(text: string): boolean {
@@ -153,3 +344,40 @@ function showToast(ctx: PluginContext, message: string): void {
 		// Toast may not be available
 	}
 }
+
+async function injectStatusMessage(
+	ctx: PluginContext,
+	sessionId: string,
+	state: CadenceSessionState
+): Promise<void> {
+	try {
+		const elapsed = getElapsedTime(state.startedAt);
+		const loopInfo = state.loopId ? ` · ${state.loopId}` : '';
+		const status = `⚡ **Cadence** · ${state.iteration}/${state.maxIterations}${loopInfo} · ${elapsed}`;
+
+		await ctx.client.session?.prompt?.({
+			path: { id: sessionId },
+			body: {
+				parts: [{ type: 'text', text: status }],
+			},
+			noReply: true,
+		});
+	} catch {
+		// Status injection may not be available
+	}
+}
+
+function getElapsedTime(startedAt: string): string {
+	if (!startedAt) return '-';
+
+	const start = new Date(startedAt).getTime();
+	if (isNaN(start)) return '-';
+
+	const now = Date.now();
+	const seconds = Math.floor((now - start) / 1000);
+
+	if (seconds < 0) return '-';
+	if (seconds < 60) return `${seconds}s`;
+	if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
+	return `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m`;
+}