hungry-ghost-hive 0.43.0 → 0.43.2

package/src/cli/commands/manager/tech-lead-lifecycle.ts

@@ -0,0 +1,210 @@
+// Licensed under the Hungry Ghost Hive License. See LICENSE.
+
+import chalk from 'chalk';
+import { getCliRuntimeBuilder, resolveRuntimeModelForCli } from '../../../cli-runtimes/index.js';
+import { loadConfig } from '../../../config/loader.js';
+import { getAgentsByType, updateAgent } from '../../../db/queries/agents.js';
+import { createLog } from '../../../db/queries/logs.js';
+import { getRequirementsByStatus } from '../../../db/queries/requirements.js';
+import { getAllTeams } from '../../../db/queries/teams.js';
+import { AgentState } from '../../../state-detectors/types.js';
+import {
+  captureTmuxPane,
+  isTmuxSessionRunning,
+  killTmuxSession,
+  spawnTmuxSession,
+} from '../../../tmux/manager.js';
+import type { CLITool } from '../../../utils/cli-commands.js';
+import { findHiveRoot as findHiveRootFromDir, getHivePaths } from '../../../utils/paths.js';
+import { generateTechLeadPrompt } from '../req.js';
+import { detectAgentState } from './agent-monitoring.js';
+import { verboseLogCtx } from './manager-utils.js';
+import { isTechLeadRestartOnCooldown } from './restart-cooldown.js';
+import type { ManagerCheckContext } from './types.js';
+import { TMUX_CAPTURE_LINES_SHORT } from './types.js';
+
+const techLeadLastRestartByAgentId = new Map<string, number>();
+
+export async function restartStaleTechLead(ctx: ManagerCheckContext): Promise<void> {
+  const maxAgeHours = ctx.config.manager.tech_lead_max_age_hours;
+  const maxAgeMs = maxAgeHours * 60 * 60 * 1000;
+  const now = Date.now();
+
+  // Phase 1: Read tech lead agents (brief lock)
+  const techLeads = await ctx.withDb(async db => {
+    const leads = getAgentsByType(db.db, 'tech_lead');
+    verboseLogCtx(ctx, `restartStaleTechLead: found ${leads.length} tech lead agent(s)`);
+    return leads.map(tl => ({
+      id: tl.id,
+      tmuxSession: tl.tmux_session,
+      cliTool: (tl.cli_tool || 'claude') as CLITool,
+      createdAt: tl.created_at,
+    }));
+  });
+
+  // Phase 2: Check sessions and restart (tmux I/O outside lock, DB writes under brief lock)
+  for (const techLead of techLeads) {
+    if (!techLead.tmuxSession) {
+      verboseLogCtx(ctx, `restartStaleTechLead: techLead=${techLead.id} skip=no_tmux_session`);
+      continue;
+    }
+
+    const sessionRunning = await isTmuxSessionRunning(techLead.tmuxSession);
+    if (!sessionRunning) {
+      verboseLogCtx(
+        ctx,
+        `restartStaleTechLead: techLead=${techLead.id} skip=session_not_running session=${techLead.tmuxSession}`
+      );
+      continue;
+    }
+
+    const createdAt = new Date(techLead.createdAt).getTime();
+    const ageMs = now - createdAt;
+    const ageHours = ageMs / (60 * 60 * 1000);
+
+    verboseLogCtx(
+      ctx,
+      `restartStaleTechLead: techLead=${techLead.id} age=${ageHours.toFixed(2)}h threshold=${maxAgeHours}h`
+    );
+
+    if (ageMs < maxAgeMs) {
+      verboseLogCtx(
+        ctx,
+        `restartStaleTechLead: techLead=${techLead.id} skip=not_stale remainingMs=${maxAgeMs - ageMs}`
+      );
+      continue;
+    }
+
+    const cooldown = isTechLeadRestartOnCooldown(
+      techLeadLastRestartByAgentId.get(techLead.id),
+      now,
+      maxAgeHours
+    );
+    if (cooldown.onCooldown) {
+      verboseLogCtx(
+        ctx,
+        `restartStaleTechLead: techLead=${techLead.id} skip=cooldown cooldownHours=${cooldown.cooldownHours} remainingMs=${cooldown.remainingMs}`
+      );
+      continue;
+    }
+
+    const output = await captureTmuxPane(techLead.tmuxSession, TMUX_CAPTURE_LINES_SHORT);
+    const stateResult = detectAgentState(output, techLead.cliTool);
+
+    verboseLogCtx(
+      ctx,
+      `restartStaleTechLead: techLead=${techLead.id} state=${stateResult.state} waiting=${stateResult.isWaiting} needsHuman=${stateResult.needsHuman}`
+    );
+
+    if (
+      !stateResult.isWaiting ||
+      stateResult.needsHuman ||
+      stateResult.state === AgentState.THINKING
+    ) {
+      verboseLogCtx(
+        ctx,
+        `restartStaleTechLead: techLead=${techLead.id} skip=not_safe_state state=${stateResult.state}`
+      );
+      continue;
+    }
+
+    verboseLogCtx(
+      ctx,
+      `restartStaleTechLead: techLead=${techLead.id} action=restarting session=${techLead.tmuxSession}`
+    );
+
+    // Kill the existing session (tmux I/O, no lock)
+    await killTmuxSession(techLead.tmuxSession);
+
+    // Spawn a new session with the same configuration (tmux I/O, no lock)
+    const hiveRoot = findHiveRootFromDir(ctx.root);
+    if (!hiveRoot) {
+      verboseLogCtx(ctx, `restartStaleTechLead: techLead=${techLead.id} error=hive_root_not_found`);
+      continue;
+    }
+
+    const paths = getHivePaths(hiveRoot);
+    const config = loadConfig(paths.hiveDir);
+    const agentConfig = config.models.tech_lead;
+    const cliTool = agentConfig.cli_tool;
+    const safetyMode = agentConfig.safety_mode;
+    const model = resolveRuntimeModelForCli(agentConfig.model, cliTool);
+
+    const runtimeBuilder = getCliRuntimeBuilder(cliTool);
+    const commandArgs = runtimeBuilder.buildSpawnCommand(model, safetyMode);
+
+    // Look up active requirement and teams to provide context to the restarted tech lead
+    const initialPrompt = await ctx.withDb(async db => {
+      const planningReqs = getRequirementsByStatus(db.db, 'planning');
+      const inProgressReqs = getRequirementsByStatus(db.db, 'in_progress');
+      const activeReq = planningReqs[0] ?? inProgressReqs[0] ?? null;
+      const teams = getAllTeams(db.db);
+
+      if (activeReq) {
+        return generateTechLeadPrompt(
+          activeReq.id,
+          activeReq.title,
+          activeReq.description,
+          teams,
+          activeReq.godmode === 1,
+          activeReq.target_branch || 'main'
+        );
+      }
+
+      return `You are the Tech Lead of Hive, an AI development team orchestrator.
+
+You have been restarted to refresh your context. No active requirement is currently being planned.
+
+## Next Steps
+
+1. Check the current status of the Hive workspace:
+\`\`\`bash
+hive status
+\`\`\`
+
+2. Check your inbox for messages from developers:
+\`\`\`bash
+hive msg inbox hive-tech-lead
+\`\`\`
+
+3. If there are pending requirements, begin planning them. If all work is complete, monitor for new requirements.`;
+    });
+
+    await spawnTmuxSession({
+      sessionName: techLead.tmuxSession,
+      workDir: ctx.root,
+      commandArgs,
+      initialPrompt,
+    });
+
+    // DB writes under brief lock
+    await ctx.withDb(async db => {
+      createLog(db.db, {
+        agentId: 'manager',
+        eventType: 'AGENT_SPAWNED',
+        status: 'info',
+        message: `Tech lead ${techLead.id} restarted for context freshness (age: ${ageHours.toFixed(1)}h)`,
+        metadata: {
+          agent_id: techLead.id,
+          tmux_session: techLead.tmuxSession,
+          age_hours: ageHours,
+          threshold_hours: maxAgeHours,
+          restart_reason: 'context_freshness',
+        },
+      });
+      updateAgent(db.db, techLead.id, {
+        status: 'working',
+        createdAt: new Date().toISOString(),
+      });
+      db.save();
+    });
+
+    techLeadLastRestartByAgentId.set(techLead.id, now);
+
+    console.log(
+      chalk.green(
+        `  Tech lead ${techLead.id} restarted for context freshness (age: ${ageHours.toFixed(1)}h)`
+      )
+    );
+  }
+}

package/src/cli/commands/my-stories.ts

@@ -6,6 +6,7 @@ import { syncStatusForStory } from '../../connectors/project-management/operatio
 import { queryAll, queryOne, run, type StoryRow } from '../../db/client.js';
 import { createLog } from '../../db/queries/logs.js';
 import { createStory, getStoryDependencies, updateStory } from '../../db/queries/stories.js';
+import { requireAgentBySession, requireStory } from '../../utils/cli-helpers.js';
 import { withHiveContext, withReadOnlyHiveContext } from '../../utils/with-hive-context.js';
 
 export const myStoriesCommand = new Command('my-stories')
@@ -123,23 +124,10 @@ myStoriesCommand
   .action(async (storyId: string, options: { session: string }) => {
     await withHiveContext(async ({ root, db }) => {
       // Find agent by session
-      const agent = queryOne<{ id: string }>(
-        db.db,
-        "SELECT id FROM agents WHERE tmux_session = ? AND status != 'terminated'",
-        [options.session]
-      );
-
-      if (!agent) {
-        console.error(chalk.red(`No agent found with session: ${options.session}`));
-        process.exit(1);
-      }
+      const agent = requireAgentBySession(db.db, options.session);
 
       // Check story exists and is available
-      const story = queryOne<StoryRow>(db.db, 'SELECT * FROM stories WHERE id = ?', [storyId]);
-      if (!story) {
-        console.error(chalk.red(`Story not found: ${storyId}`));
-        process.exit(1);
-      }
+      const story = requireStory(db.db, storyId);
 
       if (story.assigned_agent_id && story.assigned_agent_id !== agent.id) {
         console.error(chalk.red(`Story already assigned to another agent.`));
@@ -185,11 +173,7 @@ myStoriesCommand
   .description('Mark a story as complete (ready for review)')
   .action(async (storyId: string) => {
     await withHiveContext(async ({ root, db }) => {
-      const story = queryOne<StoryRow>(db.db, 'SELECT * FROM stories WHERE id = ?', [storyId]);
-      if (!story) {
-        console.error(chalk.red(`Story not found: ${storyId}`));
-        process.exit(1);
-      }
+      requireStory(db.db, storyId);
 
       run(
         db.db,
@@ -245,16 +229,7 @@ myStoriesCommand
       }
 
       await withHiveContext(async ({ db }) => {
-        const agent = queryOne<{ id: string; team_id: string | null }>(
-          db.db,
-          "SELECT id, team_id FROM agents WHERE tmux_session = ? AND status != 'terminated'",
-          [options.session]
-        );
-
-        if (!agent) {
-          console.error(chalk.red(`No agent found with session: ${options.session}`));
-          process.exit(1);
-        }
+        const agent = requireAgentBySession(db.db, options.session);
 
         if (!agent.team_id) {
           console.error(

package/src/cli/commands/pr.ts

@@ -16,15 +16,15 @@ import {
   getMergeQueue,
   getNextInQueue,
   getOpenPullRequestsByStory,
-  getPullRequestById,
   getQueuePosition,
   updatePullRequest,
 } from '../../db/queries/pull-requests.js';
-import { getStoryById, updateStory } from '../../db/queries/stories.js';
+import { updateStory } from '../../db/queries/stories.js';
 import { getTeamById } from '../../db/queries/teams.js';
 import { Scheduler } from '../../orchestrator/scheduler.js';
 import { isTmuxSessionRunning, sendToTmuxSession } from '../../tmux/manager.js';
 import { autoMergeApprovedPRs } from '../../utils/auto-merge.js';
+import { requirePullRequest, requireStory } from '../../utils/cli-helpers.js';
 import { markManualMergeRequired } from '../../utils/manual-merge.js';
 import { getExistingPRIdentifiers, syncOpenGitHubPRs } from '../../utils/pr-sync.js';
 import { extractStoryIdFromBranch, normalizeStoryId } from '../../utils/story-id.js';
@@ -57,11 +57,7 @@ prCommand
 
         // Get team from story
         let teamId = options.team || null;
-        const story = getStoryById(db.db, storyId);
-        if (!story) {
-          console.error(chalk.red(`Story not found: ${storyId}`));
-          process.exit(1);
-        }
+        const story = requireStory(db.db, storyId);
 
         teamId = story.team_id;
 
@@ -277,11 +273,7 @@ prCommand
   .description('View details of a PR')
   .action(async (prId: string) => {
     await withReadOnlyHiveContext(async ({ db }) => {
-      const pr = getPullRequestById(db.db, prId);
-      if (!pr) {
-        console.error(chalk.red(`PR not found: ${prId}`));
-        process.exit(1);
-      }
+      const pr = requirePullRequest(db.db, prId);
 
       console.log(chalk.bold(`\nPull Request: ${pr.id}\n`));
       console.log(chalk.gray(`Branch:       ${pr.branch_name}`));
@@ -317,11 +309,7 @@ prCommand
   .option('--no-merge', 'Approve without merging (manual merge needed)')
   .action(async (prId: string, options: { notes?: string; from?: string; merge?: boolean }) => {
     await withHiveContext(async ({ root, db }) => {
-      const pr = getPullRequestById(db.db, prId);
-      if (!pr) {
-        console.error(chalk.red(`PR not found: ${prId}`));
-        process.exit(1);
-      }
+      const pr = requirePullRequest(db.db, prId);
 
       if (pr.status === 'merged') {
         console.log(chalk.yellow('PR already merged.'));
@@ -443,11 +431,7 @@ prCommand
   .option('--from <session>', 'QA agent session')
   .action(async (prId: string, options: { reason: string; from?: string }) => {
     await withHiveContext(async ({ root, db }) => {
-      const pr = getPullRequestById(db.db, prId);
-      if (!pr) {
-        console.error(chalk.red(`PR not found: ${prId}`));
-        process.exit(1);
-      }
+      const pr = requirePullRequest(db.db, prId);
 
       updatePullRequest(db.db, prId, {
         status: 'rejected',

package/src/cli/commands/progress.ts

@@ -9,7 +9,7 @@ import {
 } from '../../connectors/project-management/operations.js';
 import { queryOne } from '../../db/client.js';
 import { createLog } from '../../db/queries/logs.js';
-import type { StoryRow } from '../../db/queries/stories.js';
+import { requireStory } from '../../utils/cli-helpers.js';
 import { withHiveContext } from '../../utils/with-hive-context.js';
 
 export const progressCommand = new Command('progress')
@@ -43,12 +43,7 @@ export const progressCommand = new Command('progress')
         return;
       }
 
-      const story = queryOne<StoryRow>(db.db, 'SELECT * FROM stories WHERE id = ?', [storyId]);
-
-      if (!story) {
-        console.error(chalk.red(`Story not found: ${storyId}`));
-        process.exit(1);
-      }
+      const story = requireStory(db.db, storyId);
 
       if (!story.external_subtask_key) {
         console.error(

package/src/cli/commands/resume.ts

@@ -10,10 +10,11 @@ import {
 } from '../../cli-runtimes/index.js';
 import { loadConfig } from '../../config/index.js';
 import { withTransaction } from '../../db/client.js';
-import { getAgentById, getAllAgents, updateAgent, type AgentRow } from '../../db/queries/agents.js';
+import { getAllAgents, updateAgent, type AgentRow } from '../../db/queries/agents.js';
 import { createLog } from '../../db/queries/logs.js';
 import { getTeamById } from '../../db/queries/teams.js';
 import { isTmuxAvailable, isTmuxSessionRunning, spawnTmuxSession } from '../../tmux/manager.js';
+import { requireAgent } from '../../utils/cli-helpers.js';
 import { withHiveContext } from '../../utils/with-hive-context.js';
 
 export const resumeCommand = new Command('resume')
@@ -34,11 +35,7 @@ export const resumeCommand = new Command('resume')
       let agentsToResume: AgentRow[];
 
       if (options.agent) {
-        const agent = getAgentById(db.db, options.agent);
-        if (!agent) {
-          console.error(chalk.red(`Agent not found: ${options.agent}`));
-          process.exit(1);
-        }
+        const agent = requireAgent(db.db, options.agent);
         if (agent.status === 'terminated') {
           console.error(chalk.red('Cannot resume a terminated agent'));
           process.exit(1);

package/src/cli/commands/status.ts

@@ -13,6 +13,7 @@ import {
   getStoryDependencies,
 } from '../../db/queries/stories.js';
 import { getAllTeams, getTeamByName } from '../../db/queries/teams.js';
+import { requireStory } from '../../utils/cli-helpers.js';
 import { statusColor } from '../../utils/logger.js';
 import { withReadOnlyHiveContext } from '../../utils/with-hive-context.js';
 
@@ -237,11 +238,7 @@ function showTeamStatus(db: import('sql.js').Database, teamName: string, json?:
 }
 
 function showStoryStatus(db: import('sql.js').Database, storyId: string, json?: boolean): void {
-  const story = getStoryById(db, storyId);
-  if (!story) {
-    console.error(chalk.red(`Story not found: ${storyId}`));
-    process.exit(1);
-  }
+  const story = requireStory(db, storyId);
 
   const dependencies = getStoryDependencies(db, story.id);
   const logs = getLogsByStory(db, story.id).slice(0, 10);

package/src/cli/commands/stories.ts

@@ -12,6 +12,7 @@ import {
   updateStory,
   type StoryStatus,
 } from '../../db/queries/stories.js';
+import { requireStory } from '../../utils/cli-helpers.js';
 import { statusColor } from '../../utils/logger.js';
 import { withHiveContext, withReadOnlyHiveContext } from '../../utils/with-hive-context.js';
 
@@ -144,11 +145,7 @@ storiesCommand
   .description('Show story details')
   .action(async (storyId: string) => {
     await withReadOnlyHiveContext(async ({ db }) => {
-      const story = getStoryById(db.db, storyId);
-      if (!story) {
-        console.error(chalk.red(`Story not found: ${storyId}`));
-        process.exit(1);
-      }
+      const story = requireStory(db.db, storyId);
 
       const dependencies = getStoryDependencies(db.db, story.id);
 

package/src/cluster/adapters.ts

@@ -1,7 +1,8 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
 import { run } from '../db/client.js';
-import type { ReplicatedTable, StoryRecord, TableAdapter } from './types.js';
+import { STORY_STATUS_ORDER } from '../utils/story-status.js';
+import type { ReplicatedTable, TableAdapter } from './types.js';
 import {
   asNullableNumber,
   asNullableString,
@@ -12,17 +13,7 @@ import {
   toAgentLogPayload,
 } from './utils.js';
 
-export const STORY_STATUS_ORDER: Array<StoryRecord['status']> = [
-  'draft',
-  'estimated',
-  'planned',
-  'in_progress',
-  'review',
-  'qa',
-  'qa_failed',
-  'pr_submitted',
-  'merged',
-];
+export { STORY_STATUS_ORDER };
 
 export const REPLICATED_TABLES: TableAdapter[] = [
   {

package/src/cluster/cluster-http-server.ts

@@ -0,0 +1,187 @@
+// Licensed under the Hungry Ghost Hive License. See LICENSE.
+
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'http';
+import type { ClusterConfig } from '../config/schema.js';
+import type { ClusterEvent, VersionVector } from './replication.js';
+
+interface DeltaRequest {
+  version_vector: VersionVector;
+  limit?: number;
+}
+
+interface DeltaResponse {
+  events: ClusterEvent[];
+  version_vector: VersionVector;
+}
+
+const MAX_CLUSTER_REQUEST_BODY_BYTES = 1024 * 1024; // 1 MiB
+
+export interface ClusterHttpHandlers {
+  getStatus: () => unknown;
+  handleVoteRequest: (body: unknown) => unknown;
+  handleHeartbeat: (body: unknown) => unknown;
+  getDeltaFromCache: (vector: VersionVector, limit: number) => ClusterEvent[];
+  getVersionVectorCache: () => VersionVector;
+}
+
+export class ClusterHttpServer {
+  private server: Server | null = null;
+
+  constructor(
+    private readonly config: ClusterConfig,
+    private readonly handlers: ClusterHttpHandlers
+  ) {}
+
+  async startServer(): Promise<void> {
+    this.server = createServer((req, res) => {
+      void this.handleHttpRequest(req, res);
+    });
+
+    await new Promise<void>((resolve, reject) => {
+      if (!this.server) return reject(new Error('Cluster HTTP server not initialized'));
+
+      this.server.once('error', reject);
+      this.server.listen(this.config.listen_port, this.config.listen_host, () => {
+        this.server?.removeListener('error', reject);
+        resolve();
+      });
+    });
+  }
+
+  async stopServer(): Promise<void> {
+    if (this.server) {
+      await new Promise<void>(resolve => {
+        this.server?.close(() => resolve());
+      });
+      this.server = null;
+    }
+  }
+
+  private async handleHttpRequest(req: IncomingMessage, res: ServerResponse): Promise<void> {
+    try {
+      if (!this.authorize(req)) {
+        sendJson(res, 401, { error: 'Unauthorized' });
+        return;
+      }
+
+      const method = req.method || 'GET';
+      const path = req.url?.split('?')[0] || '/';
+
+      if (method === 'GET' && path === '/cluster/v1/status') {
+        sendJson(res, 200, this.handlers.getStatus());
+        return;
+      }
+
+      if (method === 'POST' && path === '/cluster/v1/election/request-vote') {
+        const body = await readJsonBody(req);
+        const response = this.handlers.handleVoteRequest(body);
+        sendJson(res, 200, response);
+        return;
+      }
+
+      if (method === 'POST' && path === '/cluster/v1/election/heartbeat') {
+        const body = await readJsonBody(req);
+        const response = this.handlers.handleHeartbeat(body);
+        sendJson(res, 200, response);
+        return;
+      }
+
+      if (method === 'POST' && path === '/cluster/v1/events/delta') {
+        const body = (await readJsonBody(req)) as Partial<DeltaRequest>;
+        const vector = toVersionVector(body.version_vector);
+        const limit =
+          typeof body.limit === 'number' && Number.isFinite(body.limit) && body.limit > 0
+            ? Math.floor(body.limit)
+            : 2000;
+
+        const events = this.handlers.getDeltaFromCache(vector, limit);
+        sendJson(res, 200, {
+          events,
+          version_vector: this.handlers.getVersionVectorCache(),
+        } satisfies DeltaResponse);
+        return;
+      }
+
+      sendJson(res, 404, { error: 'Not found' });
+    } catch (error) {
+      if (error instanceof HttpRequestError) {
+        sendJson(res, error.statusCode, { error: error.message });
+        return;
+      }
+
+      const message = error instanceof Error ? error.message : String(error);
+      sendJson(res, 500, { error: message });
+    }
+  }
+
+  private authorize(req: IncomingMessage): boolean {
+    if (!this.config.auth_token) return true;
+
+    const authHeader = req.headers.authorization;
+    if (!authHeader) return false;
+
+    const expected = `Bearer ${this.config.auth_token}`;
+    return authHeader === expected;
+  }
+}
+
+class HttpRequestError extends Error {
+  constructor(
+    public readonly statusCode: number,
+    message: string
+  ) {
+    super(message);
+    this.name = 'HttpRequestError';
+  }
+}
+
+async function readJsonBody(
+  req: IncomingMessage,
+  maxBytes: number = MAX_CLUSTER_REQUEST_BODY_BYTES
+): Promise<unknown> {
+  const chunks: Buffer[] = [];
+  let totalBytes = 0;
+
+  for await (const chunk of req) {
+    const normalizedChunk = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    totalBytes += normalizedChunk.length;
+
+    if (totalBytes > maxBytes) {
+      throw new HttpRequestError(413, `Payload too large (max ${maxBytes} bytes)`);
+    }
+
+    chunks.push(normalizedChunk);
+  }
+
+  if (chunks.length === 0) return {};
+
+  const raw = Buffer.concat(chunks).toString('utf-8');
+  if (!raw.trim()) return {};
+
+  try {
+    return JSON.parse(raw) as unknown;
+  } catch {
+    throw new HttpRequestError(400, 'Invalid JSON payload');
+  }
+}
+
+function sendJson(res: ServerResponse, statusCode: number, body: unknown): void {
+  res.statusCode = statusCode;
+  res.setHeader('Content-Type', 'application/json');
+  res.end(JSON.stringify(body));
+}
+
+function toVersionVector(input: unknown): VersionVector {
+  if (!input || typeof input !== 'object') return {};
+
+  const vector: VersionVector = {};
+
+  for (const [key, value] of Object.entries(input as Record<string, unknown>)) {
+    const num = typeof value === 'number' ? value : Number(value);
+    if (Number.isFinite(num) && num >= 0) {
+      vector[key] = Math.floor(num);
+    }
+  }
+
+  return vector;
+}