@vibedeckx/linux-x64 0.3.27 → 0.3.28

package/dist/bin.js

@@ -207173,7 +207173,7 @@ function sessionMilestoneForTurnEnd(opts) {
     workflow_run_id: null,
     created_at: opts.createdAt
   };
-  if (opts.outcome === "completed") {
+  if (opts.outcome === "completed" || opts.outcome === "completed_with_pending_tasks") {
     return {
       ...base,
       id: sessionResultReadyId(opts.sessionId, opts.entryIndex),
@@ -207312,6 +207312,25 @@ var ClaudeCodeProvider = class {
   formatUserInput(content, _sessionId) {
     return serializeUserInput(content);
   }
+  /**
+   * `stop_task` control_request — the documented Agent SDK primitive for
+   * killing one background task, verified live against claude 2.1.238: the CLI
+   * answers `control_response { subtype: "success" }`, empties its task list
+   * and the process really dies.
+   *
+   * `request_id` is namespaced by task id so a response could be correlated;
+   * nothing reads control_response today, and it does not need to — the
+   * authoritative `background_tasks_changed` snapshot that follows is what
+   * updates the ledger. An older CLI that does not know the subtype answers an
+   * error and simply changes nothing.
+   */
+  formatStopBackgroundTask(taskId, _sessionId) {
+    return JSON.stringify({
+      type: "control_request",
+      request_id: `stop_task-${taskId}`,
+      request: { subtype: "stop_task", task_id: taskId }
+    }) + "\n";
+  }
   // Lifecycle hooks are no-ops for Claude (stateless per-session)
   onSessionCreated(_sessionId, _permissionMode) {
   }
@@ -229427,7 +229446,7 @@ function isResidentProcessInScope(candidate, scope) {
   return candidate.projectId === scope.projectId && candidate.branch === scope.branch;
 }
 function isIdleResidentProcess(candidate) {
-  return candidate.processAlive && !candidate.dormant && candidate.status !== "running" && candidate.backgroundTaskCount === 0;
+  return candidate.processAlive && !candidate.dormant && candidate.status !== "running" && !candidate.backgroundTasksProtect;
 }
 function pickIdleResidentEvictionCandidate(candidates, scope) {
   return candidates.filter((candidate) => !scope || isResidentProcessInScope(candidate, scope)).filter(isIdleResidentProcess).sort((a, b2) => a.lastActiveAt - b2.lastActiveAt)[0] ?? null;
@@ -229449,7 +229468,12 @@ var ResidentProcessLimitError = class extends Error {
 
 // src/turn-completion.ts
 var COMPLETION_GRACE_MS = 1500;
+var PARK_TIMEOUT_MS = 20 * 60 * 1e3;
 var TurnCompletionLedger = class {
+  constructor(parkTimeoutMs = PARK_TIMEOUT_MS) {
+    this.parkTimeoutMs = parkTimeoutMs;
+  }
+  parkTimeoutMs;
   /** Live background tasks by harness task_id (same id may restart). */
   tasks = /* @__PURE__ */ new Map();
   /** Held completion candidate — the latest success result, if any. */
@@ -229462,6 +229486,23 @@ var TurnCompletionLedger = class {
    * grace delay (the common case).
    */
   sawBackgroundActivity = false;
+  /**
+   * When the held candidate was parked behind live background tasks — the
+   * moment the agent stopped working and only tasks kept the turn open. The
+   * park deadline counts from here, not from when a task started: the number
+   * that matters to the user is "how long since the agent answered".
+   */
+  parkedSince = null;
+  /** Task ids the user vouched for; they stop counting toward the deadline. */
+  sanctioned = /* @__PURE__ */ new Set();
+  /**
+   * Whether a park deadline already expired and closed the turn. Live tasks
+   * normally shield the session from being reclaimed — hibernating would kill
+   * a real build and the auto-resume that reads it — but that shield must not
+   * outlast the deadline, or one stuck task pins a resident process slot
+   * forever and new sessions on the branch get turned away.
+   */
+  parkDeadlineExpired = false;
   get pendingTaskCount() {
     return this.tasks.size;
   }
@@ -229470,17 +229511,61 @@ var TurnCompletionLedger = class {
   }
   /** Live tasks in first-seen order — the payload the UI renders. */
   get backgroundTasks() {
-    return [...this.tasks.values()];
+    return [...this.tasks.values()].map(
+      (task) => this.sanctioned.has(task.taskId) ? { ...task, sanctioned: true } : task
+    );
+  }
+  /**
+   * When the parked turn will be committed anyway, or null if nothing is
+   * parked or every live task has been vouched for. Timer-free by design: the
+   * caller re-reads this after each mutation and syncs its own timer, so the
+   * ledger stays a pure state machine.
+   */
+  get parkDeadlineAt() {
+    if (this.pending === null || this.parkedSince === null) return null;
+    const allVouchedFor = [...this.tasks.keys()].every((id) => this.sanctioned.has(id));
+    return allVouchedFor ? null : this.parkedSince + this.parkTimeoutMs;
+  }
+  /**
+   * The user vouched for a task: stop counting it toward the deadline. This
+   * restores the original behavior for that task — wait for it, let the
+   * auto-resume close the turn — but now as an explicit choice.
+   */
+  sanction(taskId) {
+    if (this.tasks.has(taskId)) this.sanctioned.add(taskId);
+  }
+  /**
+   * The deadline expired: commit the parked candidate. Deliberately uses the
+   * ORIGINAL payload — its duration/cost/tokens describe the turn the agent
+   * actually ran, not the time spent waiting on a stuck task.
+   */
+  parkDeadlineElapsed() {
+    if (this.pending === null) return { kind: "none" };
+    this.parkDeadlineExpired = true;
+    return this.commitHeld();
+  }
+  /**
+   * Whether live background tasks should still shield this session from
+   * resident-process reclamation. True while they are plausibly doing real
+   * work; false once the deadline judged them anomalous — unless the user
+   * vouched for every one of them, which restores the shield along with the
+   * waiting behavior it protects.
+   */
+  get backgroundTasksProtectSession() {
+    if (this.tasks.size === 0) return false;
+    if (!this.parkDeadlineExpired) return true;
+    return [...this.tasks.keys()].every((id) => this.sanctioned.has(id));
   }
   taskStarted(task, now3) {
     this.upsert(task, this.tasks.get(task.taskId), now3);
     this.sawBackgroundActivity = true;
-    return this.rearmIfHeld();
+    return this.rearmIfHeld(now3);
   }
-  taskFinished(taskId) {
+  taskFinished(taskId, now3) {
     this.tasks.delete(taskId);
+    this.sanctioned.delete(taskId);
     this.sawBackgroundActivity = true;
-    return this.rearmIfHeld();
+    return this.rearmIfHeld(now3);
   }
   /** Authoritative snapshot from `system/background_tasks_changed`. */
   taskListChanged(tasks, now3) {
@@ -229489,8 +229574,11 @@ var TurnCompletionLedger = class {
     for (const task of tasks) {
       this.upsert(task, previous.get(task.taskId), now3);
     }
+    for (const id of this.sanctioned) {
+      if (!this.tasks.has(id)) this.sanctioned.delete(id);
+    }
     if (tasks.length > 0) this.sawBackgroundActivity = true;
-    return this.rearmIfHeld();
+    return this.rearmIfHeld(now3);
   }
   /**
    * The process emitted turn activity: if a completion was held, it was an
@@ -229502,8 +229590,10 @@ var TurnCompletionLedger = class {
    * the race against the grace window.
    */
   noteTurnActivity() {
+    this.parkDeadlineExpired = false;
     if (this.pending === null) return { kind: "none" };
     this.pending = null;
+    this.parkedSince = null;
     this.generation++;
     return { kind: "cancel" };
   }
@@ -229519,9 +229609,11 @@ var TurnCompletionLedger = class {
     this.sawBackgroundActivity = false;
     return this.noteTurnActivity();
   }
-  successResult(payload) {
+  successResult(payload, now3) {
     this.generation++;
     if (this.tasks.size > 0) {
+      this.parkedSince = now3;
+      this.parkDeadlineExpired = false;
       this.pending = payload;
       return { kind: "cancel" };
     }
@@ -229535,6 +229627,7 @@ var TurnCompletionLedger = class {
   errorResult() {
     if (this.pending === null) return { kind: "none" };
     this.pending = null;
+    this.parkedSince = null;
     this.generation++;
     return { kind: "cancel" };
   }
@@ -229560,7 +229653,10 @@ var TurnCompletionLedger = class {
   /** Full reset (fresh spawn / stop / hibernate / agent switch). */
   reset() {
     this.tasks.clear();
+    this.sanctioned.clear();
     this.pending = null;
+    this.parkedSince = null;
+    this.parkDeadlineExpired = false;
     this.generation++;
     this.sawBackgroundActivity = false;
   }
@@ -229569,10 +229665,13 @@ var TurnCompletionLedger = class {
    * have no resume behind it), so they delay the commit rather than cancel
    * it — and while tasks are still live the candidate stays parked with no
    * timer at all (only an empty set can complete a turn). */
-  rearmIfHeld() {
+  rearmIfHeld(now3) {
     if (this.pending === null) return { kind: "none" };
     this.generation++;
-    if (this.tasks.size > 0) return { kind: "cancel" };
+    if (this.tasks.size > 0) {
+      this.parkedSince ??= now3;
+      return { kind: "cancel" };
+    }
     return { kind: "schedule", generation: this.generation };
   }
   /**
@@ -229593,6 +229692,7 @@ var TurnCompletionLedger = class {
   commitHeld() {
     const payload = this.pending;
     this.pending = null;
+    this.parkedSince = null;
     this.generation++;
     return { kind: "commit", payload };
   }
@@ -229673,10 +229773,13 @@ var AgentSessionManager = class {
   retentionDeleting = /* @__PURE__ */ new Set();
   /** Grace window before committing a held completion (injectable for tests). */
   completionGraceMs;
+  /** Bound on a parked completion (injectable for tests). */
+  parkTimeoutMs;
   workflowSuppressionCheck = null;
   constructor(storage2, opts) {
     this.storage = storage2;
     this.completionGraceMs = opts?.completionGraceMs ?? COMPLETION_GRACE_MS;
+    this.parkTimeoutMs = opts?.parkTimeoutMs ?? PARK_TIMEOUT_MS;
   }
   async resolveSessionWorktreePath(session, legacyProjectPath) {
     if (!session.workspaceCheckoutId) {
@@ -229951,7 +230054,7 @@ var AgentSessionManager = class {
           processAlive: this.isProcessAlive(session),
           status: session.status,
           dormant: session.dormant,
-          backgroundTaskCount: session.completion.pendingTaskCount,
+          backgroundTasksProtect: session.completion.backgroundTasksProtectSession,
           lastActiveAt: session.lastActiveAt,
           projectId: session.projectId,
           branch: session.branch
@@ -230099,8 +230202,9 @@ var AgentSessionManager = class {
       crossRemoteMcp: opts.crossRemoteMcp,
       agentType,
       model,
-      completion: new TurnCompletionLedger(),
+      completion: new TurnCompletionLedger(this.parkTimeoutMs),
       graceTimer: null,
+      parkTimer: null,
       eventChain: Promise.resolve(),
       bgSpawnHintsThisTurn: 0,
       taskStartedThisTurn: 0,
@@ -230357,11 +230461,78 @@ var AgentSessionManager = class {
     } else if (action.kind === "schedule") {
       this.armGraceTimer(session, action.generation);
     }
+    this.syncParkTimer(session);
+  }
+  /**
+   * Keep the park timer in step with the ledger's deadline.
+   *
+   * Driven by ledger STATE rather than by an action kind, because the deadline
+   * survives across many actions (every task event returns `cancel` while a
+   * completion stays parked) and can also be lifted without any action at all
+   * when the user vouches for the last unvouched task. Re-reading the state
+   * after each mutation is the only way the two can't drift.
+   */
+  syncParkTimer(session) {
+    const deadlineAt = session.completion.parkDeadlineAt;
+    if (deadlineAt === null) {
+      if (session.parkTimer) {
+        clearTimeout(session.parkTimer);
+        session.parkTimer = null;
+      }
+      return;
+    }
+    if (session.parkTimer) return;
+    const timer = setTimeout(() => {
+      session.parkTimer = null;
+      this.enqueueSessionWork(session, async () => {
+        const action = session.completion.parkDeadlineElapsed();
+        if (action.kind !== "commit") return;
+        console.log(
+          `[AgentSession] parked completion exceeded ${this.parkTimeoutMs}ms with ${session.completion.pendingTaskCount} background task(s) still running \u2014 committing the turn anyway (session=${session.id})`
+        );
+        await this.commitCompletion(session, action.payload, "completed_with_pending_tasks");
+        this.broadcastBackgroundTasks(session);
+      }, "completion-park-deadline");
+    }, Math.max(0, deadlineAt - Date.now()));
+    timer.unref?.();
+    session.parkTimer = timer;
+  }
+  /**
+   * The user vouched for a background task: it stops counting toward the park
+   * deadline, restoring the original wait-for-auto-resume behavior for that
+   * task alone — now as an explicit choice rather than a silent assumption.
+   */
+  /**
+   * Ask the agent to stop one background task.
+   *
+   * Returns "unsupported" for agents with no such primitive (Codex), so the
+   * caller can say "stop the session instead" rather than showing a dead
+   * button. On success nothing is updated here: the CLI's own
+   * `background_tasks_changed` snapshot drains the ledger, which then commits
+   * the parked turn through the normal path.
+   */
+  stopBackgroundTask(sessionId, taskId) {
+    const session = this.sessions.get(sessionId);
+    if (!session?.process?.stdin) return "not_found";
+    const frame = getProvider(session.agentType).formatStopBackgroundTask?.(taskId, sessionId);
+    if (!frame) return "unsupported";
+    session.process.stdin.write(frame);
+    console.log(`[AgentSession] stop_task sent for ${taskId} (session=${sessionId})`);
+    return "ok";
+  }
+  sanctionBackgroundTask(sessionId, taskId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return false;
+    session.completion.sanction(taskId);
+    this.syncParkTimer(session);
+    this.broadcastBackgroundTasks(session);
+    return true;
   }
   /** Discard all turn-completion state (fresh spawn / stop / hibernate / agent switch). */
   resetCompletion(session) {
     this.clearGraceTimer(session);
     session.completion.reset();
+    this.syncParkTimer(session);
     this.broadcastBackgroundTasks(session);
   }
   /**
@@ -230376,21 +230547,32 @@ var AgentSessionManager = class {
    * stateless (no patch application, no ordering assumptions).
    */
   broadcastBackgroundTasks(session) {
-    this.broadcastRaw(session.id, {
+    this.broadcastRaw(session.id, this.backgroundTasksMessage(session));
+  }
+  /**
+   * Reported rather than inferred client-side: whether a single task can be
+   * stopped is a property of the agent (Claude Code has `stop_task`, Codex has
+   * nothing equivalent), and the server is the only side that knows. A client
+   * guessing from the agent type would drift the day Codex gains one.
+   */
+  backgroundTasksMessage(session) {
+    return {
       backgroundTasks: {
         tasks: session.completion.backgroundTasks,
-        turnParked: session.completion.hasPendingCompletion
+        turnParked: session.completion.hasPendingCompletion,
+        parkDeadlineAt: session.completion.parkDeadlineAt,
+        canStopTasks: !!getProvider(session.agentType).formatStopBackgroundTask
       }
-    });
+    };
   }
-  async commitCompletion(session, payload) {
+  async commitCompletion(session, payload, outcome = "completed") {
     const sessionId = session.id;
     console.log(`[AgentSession] taskCompleted: sessionId=${sessionId}, eventBus=${!!this.eventBus}, projectId=${session.projectId}, branch=${session.branch}`);
     const completedAt = Date.now();
     if (!session.skipDb) {
       await this.storage.agentSessions.markCompleted(sessionId, completedAt);
     }
-    const turnEndEntryIndex = await this.endActiveTurn(session, "completed");
+    const turnEndEntryIndex = await this.endActiveTurn(session, outcome);
     this.broadcastBackgroundTasks(session);
     const summaryText = extractLastAssistantText(session.store.entries);
     this.broadcastRaw(sessionId, {
@@ -230582,7 +230764,7 @@ var AgentSessionManager = class {
         console.log(`[AgentSession] Background task started: ${event.taskId} (${event.taskType ?? "?"}) \u2014 ${session.completion.pendingTaskCount} pending in ${sessionId}`);
         break;
       case "task_finished":
-        this.applyCompletionTimerAction(session, session.completion.taskFinished(event.taskId));
+        this.applyCompletionTimerAction(session, session.completion.taskFinished(event.taskId, timestamp));
         this.broadcastBackgroundTasks(session);
         console.log(`[AgentSession] Background task finished: ${event.taskId} (${event.status ?? "?"}) \u2014 ${session.completion.pendingTaskCount} pending in ${sessionId}`);
         break;
@@ -230652,7 +230834,7 @@ var AgentSessionManager = class {
             cost_usd: event.cost_usd,
             input_tokens: event.input_tokens,
             output_tokens: event.output_tokens
-          });
+          }, timestamp);
           if (action.kind === "commit") {
             await this.commitCompletion(session, action.payload);
           } else {
@@ -230995,12 +231177,7 @@ var AgentSessionManager = class {
     ws.send(JSON.stringify({ Ready: true, historyEpoch: session.historyEpoch }));
     const statusPatch = ConversationPatch.updateStatus(session.status);
     ws.send(JSON.stringify({ JsonPatch: statusPatch }));
-    const tasksMsg = {
-      backgroundTasks: {
-        tasks: session.completion.backgroundTasks,
-        turnParked: session.completion.hasPendingCompletion
-      }
-    };
+    const tasksMsg = this.backgroundTasksMessage(session);
     ws.send(JSON.stringify(tasksMsg));
     return () => {
       session.subscribers.delete(ws);
@@ -231800,8 +231977,9 @@ var AgentSessionManager = class {
         permissionMode,
         agentType: dbSession.agent_type || "claude-code",
         model: dbSession.model ?? null,
-        completion: new TurnCompletionLedger(),
+        completion: new TurnCompletionLedger(this.parkTimeoutMs),
         graceTimer: null,
+        parkTimer: null,
         eventChain: Promise.resolve(),
         bgSpawnHintsThisTurn: 0,
         taskStartedThisTurn: 0,
@@ -231992,8 +232170,9 @@ var AgentSessionManager = class {
       permissionMode,
       agentType,
       model,
-      completion: new TurnCompletionLedger(),
+      completion: new TurnCompletionLedger(this.parkTimeoutMs),
       graceTimer: null,
+      parkTimer: null,
       eventChain: Promise.resolve(),
       bgSpawnHintsThisTurn: 0,
       taskStartedThisTurn: 0,
@@ -248753,6 +248932,68 @@ var routes11 = async (fastify2) => {
       });
     }
   );
+  fastify2.post(
+    "/api/agent-sessions/:sessionId/background-tasks/:taskId/keep",
+    async (req, reply) => {
+      const userId = requireUserFacingUserId(req, reply);
+      if (userId === null) return;
+      const { sessionId, taskId } = req.params;
+      if (sessionId.startsWith("remote-")) {
+        const remoteInfo = await getAuthorizedRemoteSessionInfo(sessionId, userId);
+        if (!remoteInfo) {
+          return reply.code(404).send({ error: "Remote session not found" });
+        }
+        const result = await proxyAuto(
+          remoteInfo.remoteServerId,
+          "POST",
+          `/api/agent-sessions/${remoteInfo.remoteSessionId}/background-tasks/${encodeURIComponent(taskId)}/keep`,
+          {}
+        );
+        return reply.code(proxyStatus(result)).send(result.data);
+      }
+      const row = await fastify2.storage.agentSessions.getById(sessionId);
+      if (!row || !await fastify2.storage.projects.getById(row.project_id, userId)) {
+        return reply.code(404).send({ error: "Session not found" });
+      }
+      if (!fastify2.agentSessionManager.sanctionBackgroundTask(sessionId, taskId)) {
+        return reply.code(404).send({ error: "Session not running" });
+      }
+      return reply.code(200).send({ success: true });
+    }
+  );
+  fastify2.post(
+    "/api/agent-sessions/:sessionId/background-tasks/:taskId/stop",
+    async (req, reply) => {
+      const userId = requireUserFacingUserId(req, reply);
+      if (userId === null) return;
+      const { sessionId, taskId } = req.params;
+      if (sessionId.startsWith("remote-")) {
+        const remoteInfo = await getAuthorizedRemoteSessionInfo(sessionId, userId);
+        if (!remoteInfo) {
+          return reply.code(404).send({ error: "Remote session not found" });
+        }
+        const result = await proxyAuto(
+          remoteInfo.remoteServerId,
+          "POST",
+          `/api/agent-sessions/${remoteInfo.remoteSessionId}/background-tasks/${encodeURIComponent(taskId)}/stop`,
+          {}
+        );
+        return reply.code(proxyStatus(result)).send(result.data);
+      }
+      const row = await fastify2.storage.agentSessions.getById(sessionId);
+      if (!row || !await fastify2.storage.projects.getById(row.project_id, userId)) {
+        return reply.code(404).send({ error: "Session not found" });
+      }
+      const outcome = fastify2.agentSessionManager.stopBackgroundTask(sessionId, taskId);
+      if (outcome === "not_found") {
+        return reply.code(404).send({ error: "Session not running" });
+      }
+      if (outcome === "unsupported") {
+        return reply.code(501).send({ error: "This agent cannot stop a single background task \u2014 stop the session instead" });
+      }
+      return reply.code(200).send({ success: true });
+    }
+  );
   fastify2.post(
     "/api/agent-sessions/:sessionId/branch",
     async (req, reply) => {
@@ -251770,6 +252011,11 @@ var routes23 = async (fastify2) => {
           try {
             const message = JSON.parse(data.toString());
             if (message.type === "input" || message.type === "resize") {
+              if (message.type === "resize") {
+                console.log(
+                  `[WebSocket] resize ${processId} \u2192 ${message.cols}x${message.rows} ip=${req.ip} ua=${req.headers["user-agent"] ?? "?"}`
+                );
+              }
               handle.handleInput(message);
             }
           } catch (error48) {
@@ -251845,6 +252091,9 @@ var routes23 = async (fastify2) => {
             } else if (msg.type === "input") {
               handleInputMap.get(msg.processId)?.({ type: "input", data: msg.data });
             } else if (msg.type === "resize") {
+              console.log(
+                `[ExecutorMux] resize ${msg.processId} \u2192 ${msg.cols}x${msg.rows} ip=${req.ip} ua=${req.headers["user-agent"] ?? "?"}`
+              );
               handleInputMap.get(msg.processId)?.({ type: "resize", cols: msg.cols, rows: msg.rows });
             }
           } catch (error48) {
@@ -260532,6 +260781,12 @@ var WORKER_CAPABILITIES = {
   "http:POST /api/agent-sessions/:param/restart": { since: "0.2.0", summary: "\u91CD\u542F\u4F1A\u8BDD\u8FDB\u7A0B" },
   "http:POST /api/agent-sessions/:param/agent-type": { since: "0.2.0", summary: "\u5207\u6362 agent \u7C7B\u578B" },
   "http:POST /api/agent-sessions/:param/model": { since: "0.2.0", summary: "\u5207\u6362\u4F1A\u8BDD\u6A21\u578B" },
+  // Additive: an older worker 404s it, and the UI degrades by hiding the
+  // "keep running" button — that worker has no park deadline to defuse.
+  "http:POST /api/agent-sessions/:param/background-tasks/:param/keep": { since: "0.3.28", summary: "\u4E3A\u540E\u53F0\u4EFB\u52A1\u80CC\u4E66,\u514D\u4E8E\u8D85\u65F6\u6536\u5C3E" },
+  // Additive alongside /keep, and degrades the same way: an older worker 404s
+  // and the UI hides the button.
+  "http:POST /api/agent-sessions/:param/background-tasks/:param/stop": { since: "0.3.28", summary: "\u505C\u6B62\u5355\u4E2A\u540E\u53F0\u4EFB\u52A1" },
   "http:POST /api/path/agent-sessions/:param/branch": { since: "0.2.0", summary: "\u4ECE\u5386\u53F2\u5206\u53C9\u4F1A\u8BDD" },
   "http:POST /api/agent-sessions/:param/switch-mode": { since: "0.2.0", summary: "\u6743\u9650\u6A21\u5F0F\u5207\u6362" },
   "http:POST /api/agent-sessions/:param/accept-plan": { since: "0.2.0", summary: "\u63A5\u53D7\u8BA1\u5212(\u9000\u51FA plan \u6A21\u5F0F)" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibedeckx/linux-x64",
-  "version": "0.3.27",
+  "version": "0.3.28",
   "description": "Vibedeckx platform binaries for Linux x64",
   "os": [
     "linux"