@mndrk/agx 2.0.55 → 2.0.56

package/cloud-runtime/standalone/apps/local/src/prompt-scheduler/processor.ts

@@ -4,7 +4,7 @@ import { homedir } from 'os';
 
 import { getPromptJobStore } from './get-store';
 import { pollDueJobs } from './engine';
-import { getAgent, getAgentSkills, getProjectAgents } from '@/lib/db';
+import { getAgent, getAgentSkills, getProjectAgents, getTeamAgents } from '@/lib/db';
 import { LOCAL_USER } from '@/lib/auth-mode';
 import { loadDbParticipants } from '@/lib/agent-participants';
 import { runCliResponse, buildCliAttempts } from '@/lib/cli-runner';
@@ -40,12 +40,17 @@ let pumpScheduled = false;
 let pumpRunning = false;
 
 const AGENTS_DIR = join(homedir(), '.agx', 'agents');
-const OBJECTIVE_LINEAR_CONTROLLER_SYSTEM_CONTEXT = [
-  'You are deciding whether a scheduled objective worker should start exactly one Linear work session.',
+const OBJECTIVE_CONTROLLER_SYSTEM_CONTEXT = [
+  'You are deciding what action an objective worker should take next.',
   'Return ONLY raw JSON with no markdown fences or commentary.',
   'Valid responses:',
-  '{"decision":"stop","reason":"short reason","objectiveProgress":42,"objectiveStatus":"at_risk","projectProgress":35,"projectStatus":"at_risk"}',
-  '{"decision":"work","ticketId":"ticket-id-from-list","reason":"short reason","objectiveProgress":42,"objectiveStatus":"at_risk","projectProgress":35,"projectStatus":"at_risk"}',
+  '{"action":"work_ticket","ticketId":"ticket-id-from-list","reason":"short reason","objectiveProgress":42,"objectiveStatus":"at_risk","projectProgress":35,"projectStatus":"at_risk"}',
+  '{"action":"run_prompt","prompt":"detailed instructions for the agent to execute","reason":"short reason","objectiveProgress":42,"objectiveStatus":"at_risk","projectProgress":35,"projectStatus":"at_risk"}',
+  '{"action":"stop","reason":"short reason","objectiveProgress":42,"objectiveStatus":"at_risk","projectProgress":35,"projectStatus":"at_risk"}',
+  'Rules:',
+  '- "work_ticket": Use when a specific eligible Linear ticket should be worked now. ticketId must exactly match one of the listed ids in ELIGIBLE TICKETS.',
+  '- "run_prompt": Use when the objective needs work not captured by an existing ticket — creating new tickets, drafting docs, reviewing PRs, research, or other non-ticket work. Provide a detailed prompt.',
+  '- "stop": Use when no action should be taken right now.',
   'Percentages must be integers from 0 to 100.',
   'Statuses must be one of: on_track, at_risk, off_track, done.',
 ].join('\n');
@@ -294,9 +299,11 @@ function buildObjectiveLinearControllerPrompt(input: {
 
   sections.push(
     '',
-    'Choose "work" only when one listed ticket is clearly the right next ticket to start now.',
-    'Choose "stop" when none of the listed tickets should be worked right now.',
-    'If you choose "work", ticketId must exactly match one of the listed ids.',
+    'Choose "work_ticket" when one listed ticket is clearly the right next ticket to start now.',
+    'Choose "run_prompt" when the objective needs work not captured by an existing ticket (e.g. creating tickets, drafting docs, reviewing PRs).',
+    'Choose "stop" when no action should be taken right now.',
+    'If you choose "work_ticket", ticketId must exactly match one of the listed ids.',
+    'If you choose "run_prompt", provide a detailed prompt the executing agent will follow.',
   );
 
   return sections.join('\n');
@@ -316,7 +323,10 @@ function normalizeAssessmentStatus(value: unknown): ProjectObjectiveHealth | nul
   return normalizeProjectHealthStatus(value);
 }
 
-async function resolveObjectiveWorkerAgent(job: PromptJob): Promise<Participant> {
+async function resolveObjectiveWorkerAgent(
+  job: PromptJob,
+  teamId?: string | null,
+): Promise<Participant> {
   const participants = await loadDbParticipants();
 
   if (job.agentId) {
@@ -327,6 +337,17 @@ async function resolveObjectiveWorkerAgent(job: PromptJob): Promise<Participant>
     return assigned;
   }
 
+  if (teamId) {
+    const teamAgents = await getTeamAgents(teamId);
+    for (const teamAgent of teamAgents) {
+      const participant = participants.find((entry) => entry.id === teamAgent.agent_id) ?? null;
+      if (participant) {
+        return participant;
+      }
+    }
+    throw new Error('No agent in the assigned team is available to work this objective.');
+  }
+
   if (!job.projectId) {
     throw new Error('Objective Linear worker requires a project context to resolve an agent.');
   }
@@ -358,6 +379,43 @@ async function appendObjectiveWorkerActivity(input: {
   });
 }
 
+export async function logActionReceipt(
+  receipt: import('./types').ActionReceipt,
+  context: { jobId: string; projectId: string; objectiveId: string },
+): Promise<void> {
+  try {
+    const objectiveContext = await loadProjectObjectiveContext(
+      context.projectId,
+      context.objectiveId,
+    );
+    if (!objectiveContext) return;
+
+    const lines: string[] = [
+      `**${receipt.jobName}** — ${receipt.status}`,
+      '',
+      receipt.result,
+    ];
+    if (receipt.reason) {
+      lines.push('', `Reason: ${receipt.reason}`);
+    }
+    if (receipt.linearRunId) {
+      lines.push('', `Linear run: ${receipt.linearRunId}`);
+    }
+    if (receipt.chatRunId) {
+      lines.push('', `Chat run: ${receipt.chatRunId}`);
+    }
+
+    await appendObjectiveWorkerActivity({
+      jobId: context.jobId,
+      projectSlug: objectiveContext.project.slug,
+      objectiveKey: objectiveContext.objective.key,
+      body: lines.join('\n'),
+    });
+  } catch {
+    // Activity logging is best-effort
+  }
+}
+
 async function executeObjectiveLinearWorker(opts: {
   job: PromptJob;
   controllerContext: {
@@ -405,6 +463,7 @@ async function executeObjectiveLinearWorker(opts: {
       activeObjectiveAgents.map((entry) => entry.issueId),
     );
 
+    // Phase 1: Controller decides what action to take
     const controllerPrompt = buildObjectiveLinearControllerPrompt({
       jobPrompt: opts.job.prompt,
       objective: {
@@ -427,7 +486,7 @@ async function executeObjectiveLinearWorker(opts: {
     const controllerResult = await executePrompt({
       ...opts.controllerContext,
       prompt: controllerPrompt,
-      systemContext: OBJECTIVE_LINEAR_CONTROLLER_SYSTEM_CONTEXT,
+      systemContext: OBJECTIVE_CONTROLLER_SYSTEM_CONTEXT,
       cliArgs: opts.cliArgs,
       onSpawn: opts.onSpawn,
     });
@@ -435,12 +494,18 @@ async function executeObjectiveLinearWorker(opts: {
     if (controllerResult.status !== 'success') {
       return {
         ...controllerResult,
-        output: controllerResult.output || 'Objective controller failed before selecting a ticket.',
+        output: controllerResult.output || 'Objective controller failed before selecting an action.',
       };
     }
 
     const parsed = extractFirstJsonObject(controllerResult.output);
-    const decision = typeof parsed?.decision === 'string' ? parsed.decision.trim().toLowerCase() : '';
+    // Support both new "action" field and legacy "decision" field
+    const rawAction = typeof parsed?.action === 'string'
+      ? parsed.action.trim().toLowerCase()
+      : typeof parsed?.decision === 'string'
+        ? parsed.decision.trim().toLowerCase()
+        : '';
+    const action = rawAction === 'work' ? 'work_ticket' : rawAction;
     const reason = typeof parsed?.reason === 'string' ? parsed.reason.trim() : '';
     const objectiveProgress = normalizeAssessmentProgress(parsed?.objectiveProgress);
     const objectiveStatus = normalizeAssessmentStatus(parsed?.objectiveStatus);
@@ -450,6 +515,7 @@ async function executeObjectiveLinearWorker(opts: {
     const objectiveNote = typeof parsed?.objectiveNote === 'string' ? parsed.objectiveNote.trim() : '';
     const nowIso = new Date().toISOString();
 
+    // Health side-effects (applied regardless of action type)
     const objectiveHealthSummary =
       objectiveProgress !== null && objectiveStatus
         ? formatHealthSummary('Objective health', objectiveProgress, objectiveStatus)
@@ -503,60 +569,167 @@ async function executeObjectiveLinearWorker(opts: {
       });
     }
 
-    if (decision === 'stop') {
-      const hasNonTerminalIssues = issues.some((issue) => !isObjectiveLinearTerminalStatus(issue.status));
-      const fallbackReason =
-        issues.length === 0
-          ? 'No objective-labeled Linear tickets were found.'
-          : eligibleIssues.length === 0
-            ? hasNonTerminalIssues
-              ? 'All actionable objective tickets already have active sessions.'
-              : 'All objective tickets are already in a terminal state.'
-            : 'The controller decided that no ticket should be started right now.';
-      const stopReason = reason || fallbackReason;
-      await appendObjectiveWorkerActivity({
-        jobId: opts.job.id,
-        projectSlug: objectiveContext.project.slug,
-        objectiveKey: objectiveContext.objective.key,
-        body: [
-          'No actionable objective tickets.',
-          `Reason: ${stopReason}`,
-          objectiveHealthSummary,
-          objectiveNote || null,
-          projectHealthSummary,
-          projectNote || null,
-        ]
-          .filter((line): line is string => Boolean(line))
-          .join('\n\n'),
-      });
+    // Phase 2: Dispatch the action
+    const receipt = await dispatchObjectiveAction({
+      action,
+      parsed,
+      reason,
+      job: opts.job,
+      controllerContext: opts.controllerContext,
+      sessionAgent: opts.sessionAgent,
+      objectiveContext,
+      eligibleIssues,
+      issues,
+      healthSummaries: {
+        objectiveHealthSummary,
+        projectHealthSummary,
+        objectiveNote,
+        projectNote,
+      },
+      cliArgs: opts.cliArgs,
+      onSpawn: opts.onSpawn,
+      startMs,
+    });
+
+    // Phase 3: Log receipt to activity timeline
+    await logActionReceipt(receipt, {
+      jobId: opts.job.id,
+      projectId: opts.job.projectId,
+      objectiveId: opts.job.objectiveId!,
+    });
+
+    return {
+      output: receipt.result,
+      error: receipt.status === 'failed' ? receipt.result : '',
+      durationMs: Date.now() - startMs,
+      status: receipt.status,
+    };
+  } catch (err) {
+    return {
+      output: '',
+      error: err instanceof Error ? err.message : String(err),
+      durationMs: Date.now() - startMs,
+      status: 'failed',
+    };
+  }
+}
+
+async function dispatchObjectiveAction(opts: {
+  action: string;
+  parsed: Record<string, unknown> | null;
+  reason: string;
+  job: PromptJob;
+  controllerContext: {
+    provider: ChatProvider;
+    model: string | null;
+    identity: string | undefined;
+    self: string | undefined;
+    skills: string | undefined;
+  };
+  sessionAgent: Participant;
+  objectiveContext: NonNullable<Awaited<ReturnType<typeof loadProjectObjectiveContext>>>;
+  eligibleIssues: LinearIssueSummary[];
+  issues: LinearIssueSummary[];
+  healthSummaries: {
+    objectiveHealthSummary: string | null;
+    projectHealthSummary: string | null;
+    objectiveNote: string;
+    projectNote: string;
+  };
+  cliArgs?: string;
+  onSpawn?: (pid: number) => void;
+  startMs: number;
+}): Promise<import('./types').ActionReceipt> {
+  const { action, parsed, reason, healthSummaries } = opts;
+
+  if (action === 'stop') {
+    const hasNonTerminalIssues = opts.issues.some((issue) => !isObjectiveLinearTerminalStatus(issue.status));
+    const fallbackReason =
+      opts.issues.length === 0
+        ? 'No objective-labeled Linear tickets were found.'
+        : opts.eligibleIssues.length === 0
+          ? hasNonTerminalIssues
+            ? 'All actionable objective tickets already have active sessions.'
+            : 'All objective tickets are already in a terminal state.'
+          : 'The controller decided that no ticket should be started right now.';
+    const stopReason = reason || fallbackReason;
+
+    return {
+      action: 'stop',
+      jobName: opts.job.name,
+      reason: stopReason,
+      result: [
+        'No action taken.',
+        `Reason: ${stopReason}`,
+        healthSummaries.objectiveHealthSummary,
+        healthSummaries.objectiveNote || null,
+        healthSummaries.projectHealthSummary,
+        healthSummaries.projectNote || null,
+      ]
+        .filter((line): line is string => Boolean(line))
+        .join('\n\n'),
+      durationMs: Date.now() - opts.startMs,
+      status: 'success',
+    };
+  }
+
+  if (action === 'run_prompt') {
+    const promptText = typeof parsed?.prompt === 'string' ? parsed.prompt.trim() : '';
+    if (!promptText) {
       return {
-        output: [
-          'No actionable objective tickets.',
-          `Reason: ${stopReason}`,
-          objectiveHealthSummary,
-          projectHealthSummary,
-        ]
-          .filter((line): line is string => Boolean(line))
-          .join('\n'),
-        error: '',
-        durationMs: Date.now() - startMs,
-        status: 'success',
+        action: 'run_prompt',
+        jobName: opts.job.name,
+        reason,
+        result: 'Controller returned run_prompt but provided no prompt text.',
+        durationMs: Date.now() - opts.startMs,
+        status: 'failed',
       };
     }
 
-    if (decision !== 'work') {
-      throw new Error(`Objective worker controller returned an invalid decision: ${controllerResult.output}`);
-    }
+    const promptResult = await executePrompt({
+      ...opts.controllerContext,
+      prompt: promptText,
+      cliArgs: opts.cliArgs,
+      onSpawn: opts.onSpawn,
+    });
+
+    const summary = promptResult.status === 'success'
+      ? (promptResult.output || '').split('\n').filter(Boolean).slice(0, 10).join('\n') || 'Prompt completed.'
+      : `Prompt failed: ${promptResult.error || 'unknown error'}`;
+
+    return {
+      action: 'run_prompt',
+      jobName: opts.job.name,
+      reason,
+      result: [
+        summary,
+        healthSummaries.objectiveHealthSummary,
+        healthSummaries.projectHealthSummary,
+      ]
+        .filter((line): line is string => Boolean(line))
+        .join('\n\n'),
+      durationMs: Date.now() - opts.startMs,
+      status: promptResult.status,
+    };
+  }
 
+  if (action === 'work_ticket') {
     const ticketId = typeof parsed?.ticketId === 'string' ? parsed.ticketId.trim() : '';
-    const selectedIssue = eligibleIssues.find((issue) => issue.id === ticketId) ?? null;
+    const selectedIssue = opts.eligibleIssues.find((issue) => issue.id === ticketId) ?? null;
     if (!selectedIssue) {
-      throw new Error(`Objective worker controller selected an unknown ticket: ${ticketId || '(empty)'}`);
+      return {
+        action: 'work_ticket',
+        jobName: opts.job.name,
+        reason,
+        result: `Controller selected an unknown ticket: ${ticketId || '(empty)'}`,
+        durationMs: Date.now() - opts.startMs,
+        status: 'failed',
+      };
     }
 
     const launch = await startScriptedLinearSession({
-      projectId: objectiveContext.project.id,
-      projectSlug: objectiveContext.project.slug,
+      projectId: opts.objectiveContext.project.id,
+      projectSlug: opts.objectiveContext.project.slug,
       issue: {
         id: selectedIssue.id,
         identifier: selectedIssue.identifier,
@@ -570,46 +743,38 @@ async function executeObjectiveLinearWorker(opts: {
     const issueLink = selectedIssue.url
       ? `[${selectedIssue.identifier}](${selectedIssue.url})`
       : selectedIssue.identifier;
-    await appendObjectiveWorkerActivity({
-      jobId: opts.job.id,
-      projectSlug: objectiveContext.project.slug,
-      objectiveKey: objectiveContext.objective.key,
-      body: [
-        `Started work on ${issueLink}: ${selectedIssue.title}`,
-        reason ? `Reason: ${reason}` : null,
-        objectiveHealthSummary,
-        objectiveNote || null,
-        projectHealthSummary,
-        projectNote || null,
-        `Linear run: ${launch.run.id}`,
-      ]
-        .filter((line): line is string => Boolean(line))
-        .join('\n\n'),
-    });
 
     return {
-      output: [
-        `Started work on ${selectedIssue.identifier}: ${selectedIssue.title}`,
+      action: 'work_ticket',
+      jobName: opts.job.name,
+      reason,
+      result: [
+        `Started work on ${issueLink}: ${selectedIssue.title}`,
         reason ? `Reason: ${reason}` : null,
-        objectiveHealthSummary,
-        projectHealthSummary,
+        healthSummaries.objectiveHealthSummary,
+        healthSummaries.objectiveNote || null,
+        healthSummaries.projectHealthSummary,
+        healthSummaries.projectNote || null,
         `Linear run: ${launch.run.id}`,
-        `Chat run: ${launch.chatRunId}`,
       ]
         .filter((line): line is string => Boolean(line))
-        .join('\n'),
-      error: '',
-      durationMs: Date.now() - startMs,
+        .join('\n\n'),
+      linearRunId: launch.run.id,
+      chatRunId: launch.chatRunId,
+      durationMs: Date.now() - opts.startMs,
       status: 'success',
     };
-  } catch (err) {
-    return {
-      output: '',
-      error: err instanceof Error ? err.message : String(err),
-      durationMs: Date.now() - startMs,
-      status: 'failed',
-    };
   }
+
+  // Unknown action
+  return {
+    action: action || 'unknown',
+    jobName: opts.job.name,
+    reason,
+    result: `Controller returned an invalid action: ${action || '(empty)'}`,
+    durationMs: Date.now() - opts.startMs,
+    status: 'failed',
+  };
 }
 
 async function executeJobAction(
@@ -626,7 +791,34 @@ async function executeJobAction(
   } = {},
 ): Promise<{ output: string; error: string; durationMs: number; status: 'success' | 'failed' }> {
   if (job.executionMode === 'objective_linear_ticket') {
-    const sessionAgent = await resolveObjectiveWorkerAgent(job);
+    let teamId: string | null = null;
+
+    if (job.projectId && job.objectiveId) {
+      const objectiveContext = await loadProjectObjectiveContext(job.projectId, job.objectiveId);
+      teamId = objectiveContext?.objective.teamId ?? null;
+
+      if (!teamId) {
+        await logActionReceipt(
+          {
+            action: 'team_gate',
+            jobName: job.name,
+            status: 'failed',
+            result: 'Execution blocked: no team assigned to this objective.',
+            reason: 'Assign a team before scheduled work can run.',
+            durationMs: 0,
+          },
+          { jobId: job.id, projectId: job.projectId, objectiveId: job.objectiveId },
+        );
+        return {
+          output: '',
+          error: 'Execution blocked: no team assigned to this objective.',
+          durationMs: 0,
+          status: 'failed',
+        };
+      }
+    }
+
+    const sessionAgent = await resolveObjectiveWorkerAgent(job, teamId);
     const controllerContext = await resolveJobContextForAgent(job, sessionAgent.id);
     return executeObjectiveLinearWorker({
       job,
@@ -678,6 +870,19 @@ async function fireConditionGate(job: PromptJob, run: PromptRun) {
       finishedAt: new Date().toISOString(),
     });
     store.updateJob(job.id, { lastOutcome: 'success', lastRunAt: Date.now() });
+    if (job.objectiveId && job.projectId) {
+      await logActionReceipt(
+        {
+          action: 'gated_skip',
+          jobName: job.name,
+          reason: 'condition not met',
+          result: `Gate: ${answer}\n(condition not met — skipped action)`,
+          durationMs: gateResult.durationMs,
+          status: 'success',
+        },
+        { jobId: job.id, projectId: job.projectId, objectiveId: job.objectiveId },
+      );
+    }
     return;
   }
 
@@ -694,6 +899,22 @@ async function fireConditionGate(job: PromptJob, run: PromptRun) {
     finishedAt: new Date().toISOString(),
   });
   store.updateJob(job.id, { lastOutcome: actionResult.status, lastRunAt: Date.now() });
+
+  if (job.objectiveId && job.projectId) {
+    await logActionReceipt(
+      {
+        action: 'prompt',
+        jobName: job.name,
+        reason: 'condition gate passed',
+        result: actionResult.status === 'success'
+          ? (actionResult.output || '').split('\n').filter(Boolean).slice(0, 3).join('\n') || 'Task completed successfully.'
+          : `Task failed: ${actionResult.error || 'unknown error'}`,
+        durationMs: gateResult.durationMs + actionResult.durationMs,
+        status: actionResult.status,
+      },
+      { jobId: job.id, projectId: job.projectId, objectiveId: job.objectiveId },
+    );
+  }
 }
 
 async function fireRun(job: PromptJob, run: PromptRun) {
@@ -723,6 +944,22 @@ async function fireRun(job: PromptJob, run: PromptRun) {
     finishedAt: new Date().toISOString(),
   });
   store.updateJob(job.id, { lastOutcome: result.status, lastRunAt: Date.now() });
+
+  if (job.objectiveId && job.projectId) {
+    await logActionReceipt(
+      {
+        action: 'prompt',
+        jobName: job.name,
+        reason: '',
+        result: result.status === 'success'
+          ? (result.output || '').split('\n').filter(Boolean).slice(0, 3).join('\n') || 'Task completed successfully.'
+          : `Task failed: ${result.error || 'unknown error'}`,
+        durationMs: result.durationMs,
+        status: result.status,
+      },
+      { jobId: job.id, projectId: job.projectId, objectiveId: job.objectiveId },
+    );
+  }
 }
 
 function dispatchRun(job: PromptJob, run: PromptRun) {

package/cloud-runtime/standalone/apps/local/src/prompt-scheduler/types.ts

@@ -5,6 +5,24 @@ export type RunStatus = 'queued' | 'running' | 'success' | 'failed' | 'cancelled
 export type TriggerType = 'scheduled' | 'condition';
 export type PromptJobExecutionMode = 'prompt' | 'objective_linear_ticket';
 
+export type ObjectiveActionType = 'work_ticket' | 'run_prompt' | 'stop';
+
+export type ObjectiveAction =
+  | { action: 'work_ticket'; ticketId: string; reason: string }
+  | { action: 'run_prompt'; prompt: string; reason: string }
+  | { action: 'stop'; reason: string };
+
+export interface ActionReceipt {
+  action: string;
+  jobName: string;
+  reason: string;
+  result: string;
+  linearRunId?: string;
+  chatRunId?: string;
+  durationMs: number;
+  status: 'success' | 'failed';
+}
+
 export const DEFAULT_PROMPT_JOB_EXECUTION_MODE: PromptJobExecutionMode = 'prompt';
 export const DEFAULT_OBJECTIVE_LINEAR_WORKER_NAME = 'Work objective Linear tickets';
 export const DEFAULT_OBJECTIVE_LINEAR_WORKER_PROMPT = [
@@ -35,6 +53,8 @@ export interface PromptJob {
   condition: string;
   nextRunAt: number | null;
   lastRunAt: number | null;
+  /** Computed: previous cron occurrence (not persisted) */
+  prevScheduledAt?: number | null;
   lastOutcome: RunStatus | null;
   createdAt: string;
   updatedAt: string;

package/cloud-runtime/standalone/apps/local/state/windowState.ts

@@ -21,6 +21,7 @@ export interface SidebarState {
   linearTicketPanelWidth: number;
   linearRunsPanelWidth: number;
   objectiveChatPanelWidth: number;
+  objectiveListPanelWidth: number;
 }
 
 export interface ScrollState {
@@ -42,6 +43,7 @@ const DEFAULT_SIDEBAR: SidebarState = {
   linearTicketPanelWidth: 576,
   linearRunsPanelWidth: 224,
   objectiveChatPanelWidth: 440,
+  objectiveListPanelWidth: 320,
 };
 
 const DEFAULT_SCROLL: ScrollState = {
@@ -203,6 +205,15 @@ export function persistObjectiveChatPanelWidth(width: number): void {
   persistSidebarState({ objectiveChatPanelWidth: width });
 }
 
+// Objective list panel width
+export function loadObjectiveListPanelWidth(): number {
+  return loadSidebarState().objectiveListPanelWidth;
+}
+
+export function persistObjectiveListPanelWidth(width: number): void {
+  persistSidebarState({ objectiveListPanelWidth: width });
+}
+
 // Clear all window state (for logout/reset)
 export function clearWindowState(): void {
   if (!isStorageAvailable()) return;

package/cloud-runtime/standalone/apps/local/styles/workspaceSidebar.css

@@ -17,6 +17,32 @@
   overflow: hidden;
 }
 
+.workspace-sidebar__backdrop {
+  position: fixed;
+  inset: 0;
+  z-index: 54;
+  border: 0;
+  background: rgba(15, 23, 42, 0.48);
+  padding: 0;
+  margin: 0;
+}
+
+.workspace-sidebar--drawer {
+  position: fixed;
+  left: 0;
+  top: 0;
+  z-index: 55;
+  width: min(360px, 80vw);
+  min-width: min(360px, 80vw);
+  height: 100dvh;
+  box-shadow: 0 18px 48px rgba(15, 23, 42, 0.28);
+}
+
+.workspace-sidebar--drawer-phone {
+  width: min(100vw, 26rem);
+  min-width: min(100vw, 26rem);
+}
+
 .workspace-sidebar--collapsed {
   width: 3.5rem;
   min-width: 3.5rem;
@@ -562,3 +588,42 @@
   background: var(--app-shell-subtle);
   color: var(--foreground);
 }
+
+@media (hover: none), (pointer: coarse) {
+  .workspace-sidebar__nav-item,
+  .workspace-sidebar__section-link,
+  .workspace-sidebar__settings-button,
+  .workspace-sidebar__action,
+  .workspace-sidebar__workspace-action {
+    min-height: 2.75rem;
+  }
+
+  .workspace-sidebar__brand {
+    padding-top: calc(0.75rem + env(safe-area-inset-top));
+  }
+
+  .workspace-sidebar__content {
+    padding-bottom: calc(1rem + env(safe-area-inset-bottom));
+  }
+
+  .workspace-sidebar__workspace-nav-item {
+    padding-right: 5.5rem;
+  }
+
+  .workspace-sidebar__workspace-actions {
+    opacity: 1;
+    gap: 0.35rem;
+    right: 0.5rem;
+  }
+
+  .workspace-sidebar__workspace-action {
+    width: 2rem;
+    height: 2rem;
+    border-color: var(--app-shell-border);
+  }
+
+  .workspace-sidebar__action {
+    width: 2.25rem;
+    height: 2.25rem;
+  }
+}