feat(remote): create projects and pick an agent from the phone

.gitignore

@@ -49,3 +49,6 @@ docs/*
 
 # Local scratch space (UI preview harnesses, throwaway scripts)
 /.tmp/
+GEMINI.md
+.idea/
+CLAUDE.md

android/app/src/main/java/com/parallelcode/phone/RemoteClient.kt

@@ -60,7 +60,7 @@ private const val SLOW_REQUEST_SECONDS = 130L
 /** [json] is the error reply's body, for routes that explain a refusal (e.g. close warnings). */
 class ApiException(message: String, val status: Int = 0, val json: JSONObject? = null) : IOException(message)
 
-data class MobileProject(val id: String, val name: String, val agentName: String?)
+data class MobileProject(val id: String, val name: String, val agentName: String?, val path: String? = null)
 
 /** What another saved computer reported in the last poll, under the name the phone shows for it. */
 data class ComputerSnapshot(val label: String, val agents: List<RemoteAgent>, val usage: List<ProviderUsage>)
@@ -322,10 +322,22 @@ class RemoteClient(
         val list = JSONArray(apiRaw("GET", "/api/mobile/projects", null, pairedTokenOrThrow()))
         return List(list.length()) { i ->
             val p = list.getJSONObject(i)
-            MobileProject(p.getString("id"), p.getString("name"), p.optString("agentName").ifEmpty { null })
+            MobileProject(
+                p.getString("id"),
+                p.getString("name"),
+                p.optString("agentName").ifEmpty { null },
+                p.optString("path").ifEmpty { null },
+            )
         }
     }
 
+    /** Create a new git project folder on the desktop and add it; returns the project. */
+    suspend fun createProject(name: String, parentDir: String): MobileProject {
+        val body = JSONObject().put("name", name).put("parentDir", parentDir)
+        val p = api("POST", "/api/mobile/projects", body, pairedTokenOrThrow())
+        return MobileProject(p.getString("id"), p.getString("name"), null, p.optString("path").ifEmpty { null })
+    }
+
     /**
      * Agents and models a paired phone may start tasks with. Empty from a desktop that predates
      * the route: it refuses unknown paths for a paired token with 403. Tasks then use its

android/app/src/main/java/com/parallelcode/phone/TaskScreens.kt

@@ -10,17 +10,20 @@ import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
 import androidx.compose.animation.shrinkVertically
 import androidx.compose.animation.togetherWith
+import androidx.compose.foundation.BorderStroke
 import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.interaction.collectIsPressedAsState
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.horizontalScroll
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.heightIn
 import androidx.compose.foundation.layout.imePadding
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.selection.selectable
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.verticalScroll
 import androidx.compose.material3.Button
@@ -74,6 +77,9 @@ fun NewTaskScreen(client: RemoteClient, onDone: () -> Unit, onNeedsPairing: () -
     var prompt by rememberSaveable { mutableStateOf("") }
     var busy by remember { mutableStateOf(false) }
     var error by remember { mutableStateOf<String?>(null) }
+    var addingProject by rememberSaveable { mutableStateOf(false) }
+    var newProjectName by rememberSaveable { mutableStateOf("") }
+    var newProjectParent by rememberSaveable { mutableStateOf("") }
     // Same default title as the phone web UI: the start of the prompt.
     val title = name.trim().ifEmpty { prompt.trim().replace(Regex("\\s+"), " ").take(80) }
 
@@ -141,6 +147,12 @@ fun NewTaskScreen(client: RemoteClient, onDone: () -> Unit, onNeedsPairing: () -
                 .padding(16.dp),
             verticalArrangement = Arrangement.spacedBy(14.dp),
         ) {
+            Text(
+                "PROJECT",
+                style = MaterialTheme.typography.labelSmall,
+                fontWeight = FontWeight.Bold,
+                color = AppTheme.extra.textMuted,
+            )
             val loaded = projects
             when {
                 loaded == null -> Text("Loading projects…", color = AppTheme.extra.textMuted)
@@ -194,6 +206,61 @@ fun NewTaskScreen(client: RemoteClient, onDone: () -> Unit, onNeedsPairing: () -
                     }
                 }
             }
+            if (addingProject) {
+                OutlinedTextField(
+                    value = newProjectName,
+                    onValueChange = { newProjectName = it },
+                    modifier = Modifier.fillMaxWidth(),
+                    label = { Text("New project name") },
+                    singleLine = true,
+                    enabled = !busy,
+                    shape = MaterialTheme.shapes.large,
+                )
+                OutlinedTextField(
+                    value = newProjectParent,
+                    onValueChange = { newProjectParent = it },
+                    modifier = Modifier.fillMaxWidth(),
+                    label = { Text("Folder on your computer") },
+                    supportingText = { Text("A new git repository is created inside it.") },
+                    singleLine = true,
+                    enabled = !busy,
+                    shape = MaterialTheme.shapes.large,
+                )
+                Button(
+                    modifier = Modifier.fillMaxWidth(),
+                    enabled = !busy && newProjectName.isNotBlank() && newProjectParent.isNotBlank(),
+                    shape = MaterialTheme.shapes.large,
+                    onClick = {
+                        busy = true
+                        error = null
+                        scope.launch {
+                            try {
+                                val created = client.createProject(newProjectName.trim(), newProjectParent.trim())
+                                projects = (projects ?: emptyList()) + created
+                                projectId = created.id
+                                newProjectName = ""
+                                addingProject = false
+                            } catch (e: ApiException) {
+                                failed(e)
+                            } finally {
+                                busy = false
+                            }
+                        }
+                    },
+                ) { Text(if (busy) "Creating…" else "Create project", fontWeight = FontWeight.Bold) }
+            } else if (projects != null) {
+                TextButton(
+                    onClick = {
+                        if (newProjectParent.isEmpty()) {
+                            // Suggest the folder the existing projects already live in.
+                            newProjectParent = projects?.firstNotNullOfOrNull { it.path }
+                                ?.substringBeforeLast('/', "").orEmpty()
+                        }
+                        addingProject = true
+                    },
+                    enabled = !busy,
+                ) { Text("New project…") }
+            }
             OutlinedTextField(
                 value = prompt,
                 onValueChange = { prompt = it },

electron/ipc/channel-manifest.json

@@ -86,8 +86,9 @@
   "GetRemoteStatus": "get_remote_status",
   "GeneratePairingPin": "generate_pairing_pin",
   "Remote_GetProjectsRequest": "remote_get_projects_request",
-  "Remote_CreateTaskRequest": "remote_create_task_request",
   "Remote_GetAgentsRequest": "remote_get_agents_request",
+  "Remote_CreateTaskRequest": "remote_create_task_request",
+  "Remote_AddProjectRequest": "remote_add_project_request",
   "MCP_ReadMindMapRequest": "mcp_read_mindmap_request",
   "MCP_ReadReasoningRequest": "mcp_read_reasoning_request",
   "MCP_UpdateReasoningRequest": "mcp_update_reasoning_request",
@@ -106,6 +107,7 @@
   "Remote_GetDiffRequest": "remote_get_diff_request",
   "Remote_GetMergeReadinessRequest": "remote_get_merge_readiness_request",
   "Remote_MergeTaskRequest": "remote_merge_task_request",
+  "Remote_GetUsageRequest": "remote_get_usage_request",
   "Remote_GetFixCiPromptRequest": "remote_get_fix_ci_prompt_request",
   "Remote_SendFixCiPromptRequest": "remote_send_fix_ci_prompt_request",
   "Remote_UpdateTaskStatus": "remote_update_task_status",

electron/ipc/register-wiring.test.ts

@@ -87,6 +87,7 @@ const NOT_HANDLED_HERE: readonly string[] = [
   IPC.NotificationFailed,
   IPC.PlanContent,
   IPC.PrChecksUpdate,
+  IPC.Remote_AddProjectRequest,
   IPC.Remote_CloseTaskRequest,
   IPC.Remote_CreateTaskRequest,
   IPC.Remote_GetAgentsRequest,
@@ -97,6 +98,7 @@ const NOT_HANDLED_HERE: readonly string[] = [
   IPC.Remote_GetFixCiPromptRequest,
   IPC.Remote_SendFixCiPromptRequest,
   IPC.Remote_MergeTaskRequest,
+  IPC.Remote_GetUsageRequest,
   IPC.Remote_SetNotesRequest,
   IPC.SuperProductivityOpenTaskRequested,
   IPC.UpdateStatusChanged,

electron/ipc/register.ts

@@ -73,6 +73,7 @@ import { readCoverageSummary } from './coverage.js';
 import { loadEslintQualityFindings } from './eslint-quality-findings.js';
 import { buildVerifyEnv, validateVerifyCommand, verificationRunner } from './verify.js';
 import { scanEvidence } from './evidence-scan.js';
+import { createProjectFolder } from '../remote/project-create.js';
 import {
   startRemoteServer,
   getMCPLogs,
@@ -88,6 +89,7 @@ import type {
   RemoteTaskContext,
   RemoteTaskDiff,
 } from '../remote/protocol.js';
+import type { UsageProvider, UsageState } from './shared-types.js';
 import { atomicWriteFileSync } from '../mcp/atomic.js';
 import { getUserDataDir } from '../user-data-dir.js';
 import {
@@ -1801,6 +1803,13 @@ export function registerAllHandlers(win: BrowserWindow): void {
     getAgentChoices: () => callRenderer<RemoteAgentChoice[]>(IPC.Remote_GetAgentsRequest, {}),
     createTaskFromMobile: (req: MobileTaskRequest) =>
       callRenderer<{ taskId: string }>(IPC.Remote_CreateTaskRequest, req),
+    createProjectFromMobile: async (req: { parentDir: string; name: string }) => {
+      const projectPath = await createProjectFolder(req.parentDir, req.name);
+      return callRenderer<RemoteProject>(IPC.Remote_AddProjectRequest, {
+        name: path.basename(projectPath),
+        path: projectPath,
+      });
+    },
     getTaskNotes: (taskId: string) =>
       callRenderer<{ notes: string }>(IPC.Remote_GetNotesRequest, { taskId }).then((r) => r.notes),
     setTaskNotes: (taskId: string, notes: string) =>
@@ -1821,6 +1830,7 @@ export function registerAllHandlers(win: BrowserWindow): void {
       ),
     mergeTaskFromMobile: (req: { taskId: string; squash: boolean; cleanup: boolean }) =>
       callRenderer<{ ok: boolean }>(IPC.Remote_MergeTaskRequest, req).then(() => {}),
+    getUsage: () => callRenderer<Record<UsageProvider, UsageState>>(IPC.Remote_GetUsageRequest, {}),
     getTaskAttention: (taskId: string): RemoteAttentionState => taskAttention.get(taskId) ?? 'idle',
     getTaskContext: (taskId: string) => taskContext.get(taskId),
     getCollapsedTaskIds: (): string[] => {

electron/ipc/shared-types.ts

@@ -361,6 +361,18 @@ export type UsageResult =
   /** Transient failure — the renderer keeps its last good snapshot. */
   | { status: 'error'; message: string };
 
+/** The renderer's view of one provider's usage, also served to the phone. */
+export interface UsageState {
+  fiveHour: UsageWindow | null;
+  sevenDay: UsageWindow | null;
+  creditUsage?: CreditUsage | null;
+  /** When the current windows were fetched; null until the first success. */
+  fetchedAt: number | null;
+  /** `unavailable` means no subscription login — the bar hides. `error` keeps the last snapshot. */
+  status: 'idle' | 'ok' | 'error' | 'unavailable';
+  error: string | null;
+}
+
 /** One OS process in the resources panel. */
 export interface ResourceProcess {
   pid: number;

electron/preload.cjs

@@ -93,8 +93,9 @@ const ALLOWED_CHANNELS = new Set([
   'get_remote_status',
   'generate_pairing_pin',
   'remote_get_projects_request',
-  'remote_create_task_request',
   'remote_get_agents_request',
+  'remote_create_task_request',
+  'remote_add_project_request',
   'mcp_read_mindmap_request',
   'mcp_read_reasoning_request',
   'mcp_update_reasoning_request',
@@ -113,6 +114,7 @@ const ALLOWED_CHANNELS = new Set([
   'remote_get_diff_request',
   'remote_get_merge_readiness_request',
   'remote_merge_task_request',
+  'remote_get_usage_request',
   'remote_get_fix_ci_prompt_request',
   'remote_send_fix_ci_prompt_request',
   'remote_update_task_status',

electron/remote/notes-route.test.ts

@@ -246,3 +246,41 @@ describe('notes route without a renderer bridge', () => {
     expect(res.status).toBe(503);
   });
 });
+
+describe('GET /api/mobile/usage', () => {
+  const usage = {
+    claude: {
+      fiveHour: { usedPercent: 40, resetsAt: null },
+      sevenDay: null,
+      fetchedAt: 1,
+      status: 'ok' as const,
+      error: null,
+    },
+    codex: {
+      fiveHour: null,
+      sevenDay: null,
+      fetchedAt: null,
+      status: 'idle' as const,
+      error: null,
+    },
+  };
+  const getUsage = vi.fn(async () => usage);
+  beforeEach(() => start({ getUsage }));
+
+  it('returns the desktop snapshot for mobile and paired tokens', async () => {
+    for (const token of [mobileToken, await pair()]) {
+      const res = await request('GET', '/api/mobile/usage', { token });
+      expect(res.status).toBe(200);
+      expect(res.json).toEqual(usage);
+    }
+  });
+
+  it('rejects agent tokens and non-GET methods', async () => {
+    getUsage.mockClear();
+    for (const token of [coordinatorToken, subtaskToken]) {
+      expect((await request('GET', '/api/mobile/usage', { token })).status).toBe(403);
+    }
+    expect((await request('POST', '/api/mobile/usage', { token: mobileToken })).status).toBe(405);
+    expect(getUsage).not.toHaveBeenCalled();
+  });
+});

electron/remote/pairing.test.ts

@@ -111,6 +111,7 @@ async function startServer(enableRemembered = true) {
 beforeEach(async () => {
   createTaskFromMobile.mockClear();
   getProjects.mockClear();
+  getAgentChoices.mockClear();
   credentialsDir = mkdtempSync(join(tmpdir(), 'phone-pairing-'));
   await startServer();
 });
@@ -316,13 +317,15 @@ describe('paired-mobile routes', () => {
       projectId: 'proj-1',
       name: 'Fix bug',
       prompt: 'Investigate the crash',
+      agentId: 'claude',
     });
     expect(res.status).toBe(201);
     expect(await res.json()).toEqual({ taskId: 'task-123' });
     expect(createTaskFromMobile).toHaveBeenCalledWith({
       projectId: 'proj-1',
       name: 'Fix bug',
       prompt: 'Investigate the crash',
+      agentId: 'claude',
     });
   });
 

electron/remote/project-create.test.ts

@@ -0,0 +1,30 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { createProjectFolder } from './project-create.js';
+
+describe('createProjectFolder', () => {
+  let parent: string;
+  beforeEach(() => {
+    parent = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-newproj-'));
+  });
+  afterEach(() => {
+    fs.rmSync(parent, { recursive: true, force: true });
+  });
+
+  it('creates a git repository in a new folder', async () => {
+    const created = await createProjectFolder(parent, ' demo ');
+    expect(created).toBe(path.join(parent, 'demo'));
+    expect(fs.existsSync(path.join(created, '.git'))).toBe(true);
+  });
+
+  it('refuses an existing folder, a missing parent and path-like names', async () => {
+    fs.mkdirSync(path.join(parent, 'taken'));
+    await expect(createProjectFolder(parent, 'taken')).rejects.toThrow('already exists');
+    await expect(createProjectFolder(path.join(parent, 'nope'), 'x')).rejects.toThrow('parent');
+    await expect(createProjectFolder('relative/dir', 'x')).rejects.toThrow('absolute');
+    for (const bad of ['', '..', 'a/b', 'a\\b', 'a\nb'])
+      await expect(createProjectFolder(parent, bad)).rejects.toThrow();
+  });
+});