wisp-agents 0.17.0 → 0.18.0

package/CHANGELOG.md

@@ -5,6 +5,26 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 
 ## [Unreleased]
 
+## [0.18.0] - 2026-10-19
+
+### Added
+
+- **Merge conflicts on shipped PRs fix themselves.** When something lands on `main` and your shipped PR no longer merges, the task used to sit there until you noticed on GitHub. Now wisp sees it on its PR check (every minute, or when you press refresh): GitHub reports the PR as conflicting, and wisp confirms it locally with `git merge-tree` against a fresh fetch of the base, so a stale GitHub answer can't start a run. The task then gets a follow-up asking it to merge `origin/main` in (no rebase, since the branch is pushed), resolve each conflict keeping both sides' intent, run the cheap checks and commit. When that run ends, wisp checks the merge is complete: no unmerged files, the base is in the branch, no leftover `<<<<<<<` markers. Then it pushes to the PR, and the card shows the usual Push → PR track. While it works, the PR row reads *Fixing merge conflicts* and hides Merge. If the agent stops halfway, nothing is pushed: the card comes back unread with *Conflicts not fixed* and the reason, plus a **Fix conflicts** button to try again. wisp tries once per PR head and at most 3 times per task, so a base that keeps moving can't run up the bill. On by default; turn it off in Settings → General → **Fix PR conflicts** (`defaults.fixConflicts: "off"`). API: `conflict` on the PR, `conflictFix` on the session summary, `POST /api/sessions/:id/fix-conflicts`.
+
+- **Tasks without a folder.** The launcher has a **No folder** chip next to your projects, for general asks that have nothing to do with a repo (explain a concept, draft a message, research something). The agent runs in an empty scratch directory under `~/.wisp/scratch`, with no worktree, and the task shows under *General*. The folder is not added to your projects. The Worktree toggle hides while No folder is picked, and deleting the task deletes its scratch folder. API: `POST /api/sessions {"prompt","scratch":true}`.
+
+- **Add a project from a GitHub URL.** Paste `https://github.com/owner/repo` (or `git@github.com:owner/repo.git`, a link to any page inside the repo, or any other git URL) into Projects and the button turns into **Clone**. Click it and the dialog closes: the launcher already points at the repo (a chip with a spinner, *cloning…*) and the prompt has focus, so you write the task while it clones. Send it before the clone finishes and the task card shows *Cloning owner/repo*, then starts in the clone. If the clone fails, a toast says why, the launcher goes back to the project you had picked and your task comes back into the box. A feed filtered to another project switches to All, so the launcher isn't pulled back to that project. GitHub repos go through `gh repo clone` when gh is installed, so private repos work with your gh login; otherwise plain `git clone`. Repos land in `~/code` (or the first of `~/dev`, `~/Developer`, `~/projects`, `~/src`, `~/repos`… that exists). Click the path in the hint to change it (`defaults.cloneDir`). If the folder there already is that repo, wisp reuses it; another folder with that name gets a `-2` suffix. When gh is signed in, the dialog also lists **Your GitHub repos**, newest push first and minus ones already added, so cloning one is a single click. On a machine tab the clone happens on that machine. CLI: `wisp add https://github.com/owner/repo`. API: `POST /api/projects {"repo":"…"}`; a URL in `path` works too.
+
+### Changed
+
+- **Project chips stay on one row with tens of projects.** The launcher's *in* row used to show every project as a chip (30 projects meant 6 rows on desktop and 14 on a phone), and the top bar cut off whatever didn't fit with no way to scroll to it. Now both show your most recent projects as chips, and the rest go behind a **+N** chip. Fewer chips show when the space is narrow, and a chip is never cut in half. The project you picked, the one you're filtering by, and projects with tasks that need you always keep their chip. **+N** opens a searchable list of every project: type to filter by name or path, use ↑/↓ and Enter to pick. It also has *No folder* and *Other folder…* in the launcher, and *All projects* and *Manage projects…* in the top bar. In the top bar, **+N** shows a badge counting the tasks that need you in the projects it hides. When a phone is too narrow even for *All*, the top bar shows one chip with the current filter that opens the list.
+
+- **Ship it no longer holds you in its dialog.** Clicking *Commit, push & open PR* used to leave the dialog open with a disabled *Shipping…* button until the push and `gh pr create` were done. Now the dialog closes right away, and the card's PR row (just above the composer) shows a live track: **Commit → Push → Open PR**, with a spinner on the step that's running and a check on each one that's done. The server reports each step as `shipping` on the session summary, so other tabs see it too, and the card head shows a *Shipping* pill while the card is collapsed. When the PR is up, the row turns into the PR row with a short highlight, and a toast links to it. If a step fails, the row turns red and says which step failed and why, with **Retry**, which reopens the dialog with your commit message and description still filled in. A second ship while one is running is refused with 409.
+
+### Fixed
+
+- **The launcher is there from the first frame.** On start, the launcher used to sit as an empty strip for one to five seconds, because the page waited for harness detection (`GET /api/agents` runs every CLI, and opencode lists its models) before drawing it. Now `index.html` draws the launcher's shape with a prompt box that already has focus, so you can start typing before the scripts load. The full launcher fills in about 50 ms later, at the same height, and keeps what you typed. Harnesses come from the last list seen (kept in the browser) and refresh when detection answers. `GET /api/agents` now answers from the last detection right away and checks again in the background, sending an `agents` event if anything changed. Warm calls dropped from about 1.2 s to 2 ms. `?fresh=1` and Re-check still wait for a full detection. Empty feed sections no longer flash their headings before the feed loads.
+
 ## [0.17.0] - 2026-10-19
 
 ### Added
@@ -314,7 +334,8 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 - Session queue with follow-ups, answers to agent questions, terminal takeover and mark-as-done.
 - Older turns are folded, with a floating collapse-all button and back-to-top.
 
-[Unreleased]: https://github.com/M0xoo/wisp/compare/v0.17.0...HEAD
+[Unreleased]: https://github.com/M0xoo/wisp/compare/v0.18.0...HEAD
+[0.18.0]: https://github.com/M0xoo/wisp/compare/v0.17.0...v0.18.0
 [0.17.0]: https://github.com/M0xoo/wisp/compare/v0.16.0...v0.17.0
 [0.16.0]: https://github.com/M0xoo/wisp/compare/v0.15.0...v0.16.0
 [0.15.0]: https://github.com/M0xoo/wisp/compare/v0.14.0...v0.15.0

package/README.md

@@ -54,7 +54,7 @@ From there you can **follow up**, **answer its questions**, **take it over** in
 | 🤝 **Subagents** | Give the lead agent a team on other harnesses (e.g. Claude Code hands tests to Codex ×3). It delegates through a `delegate` tool; their edits land in its worktree. See [Subagents](#subagents). |
 | ⏪ **Checkpoints & rollback** | Every turn is snapshotted first. Restore to before any turn, revert a single file, or re-run a command block from the presentation. |
 | ⚖️ **Compare** | Run one task on two harnesses side by side, and keep the better run. |
-| 🧾 **Recipes & triggers** | Saved prompts with `{params}` (`wisp run release 0.17.0`), run by hand, on a schedule, when CI fails, or when an issue is labelled. |
+| 🧾 **Recipes & triggers** | Saved prompts with `{params}` (`wisp run release 0.18.0`), run by hand, on a schedule, when CI fails, or when an issue is labelled. |
 | 📊 **Usage** | Spend, success rate and questions per project and per harness · model. |
 | 📱 **Phone** | Questions and finished tasks on ntfy or Telegram; answer from there, or start a task with `/new`. |
 | 🔐 **Permission modes** | Choose **Plan** (read-only), **Edits** (file edits auto-accepted), or **Full auto** (no permission prompts, the default) for each launch. `Shift+Tab` in the prompt cycles modes. In Edits mode, anything the permissions block comes to you: Claude Code waits for **Allow / Always / Deny**, and the other harnesses show an **Allow & retry** card. |
@@ -83,7 +83,7 @@ brew install m0xoo/tap/wisp-agents             # Homebrew: CLI and browser mode,
 wisp "fix the flaky auth test"
 ```
 
-The Homebrew formula lives in [M0xoo/homebrew-tap](https://github.com/M0xoo/homebrew-tap). `install.sh` honors `WISP_VERSION` to pin a release (`curl -fsSL https://mokh.xyz/install.sh | WISP_VERSION=0.17.0 bash`).
+The Homebrew formula lives in [M0xoo/homebrew-tap](https://github.com/M0xoo/homebrew-tap). `install.sh` honors `WISP_VERSION` to pin a release (`curl -fsSL https://mokh.xyz/install.sh | WISP_VERSION=0.18.0 bash`).
 
 From source:
 
@@ -116,6 +116,7 @@ The CLI talks to a running wisp, or starts one if none is running. It works from
 wisp                              # open wisp (or focus the running one)
 wisp "fix the flaky auth test"    # launch a task in this folder (it becomes a project)
 wisp add [path]                   # add a folder as a project (default: cwd)
+wisp add <repo-url>               # clone a repo (GitHub URL, git@…, any git URL) into ~/code, then add it
 wisp --mode plan "audit deps"     # permission mode: plan | edits | auto
 wisp --agent codex "add a test"   # harness: claude | codex | opencode | cursor | antigravity | grok
 ```
@@ -131,7 +132,7 @@ wisp reply <id> "also do X"       # follow up (answers a pending question; --mod
 wisp stop <id>
 wisp ship <id> [--draft]          # commit, push and open a PR for a worktree task
 wisp merge <id>                   # squash-merge its PR, fast-forward your local main
-wisp run release 0.17.0            # run a recipe; values fill its {params} (or version=0.17.0)
+wisp run release 0.18.0            # run a recipe; values fill its {params} (or version=0.18.0)
 wisp recipes                      # list recipes
 wisp usage [--days 7]             # spend and outcomes
 wisp mcp                          # MCP server for other agents and editors
@@ -334,7 +335,7 @@ Before each turn, wisp snapshots the git working tree (pinned at `refs/wisp/chec
 Prepare release {version}: update CHANGELOG, README and docs/, bump package.json, tag v{version}.
 ```
 
-Make one from ⌘K → *Recipes*, or *Save as recipe…* on any card. A recipe may pin a project, harness, model and mode. Run it from ⌘K (*Run: Release*), from the Recipes view, or from a terminal: `wisp run release 0.17.0` fills the fields in order, `wisp run release version=0.17.0` by name.
+Make one from ⌘K → *Recipes*, or *Save as recipe…* on any card. A recipe may pin a project, harness, model and mode. Run it from ⌘K (*Run: Release*), from the Recipes view, or from a terminal: `wisp run release 0.18.0` fills the fields in order, `wisp run release version=0.18.0` by name.
 
 **Triggers** launch sessions on their own while wisp is open (⌘K → *Triggers*):
 

package/bin/wisp.js

@@ -236,8 +236,10 @@ async function interactive() {
 
   let openPath = '/';
   if (command === 'add') {
-    const dir = path.resolve(words[1] || process.cwd());
-    const p = await api('/projects', { path: dir }).catch((e) => console.error(`  ✗ ${e.message}`));
+    // A repo URL is cloned by the server (into ~/code unless defaults.cloneDir says otherwise).
+    const url = /^(https?:|ssh:|git:|git@|(www\.)?github\.com\/)/i.test(words[1] || '');
+    if (url) console.log(`  ◌ cloning ${words[1]}…`);
+    const p = await api('/projects', url ? { repo: words[1] } : { path: path.resolve(words[1] || process.cwd()) }).catch((e) => console.error(`  ✗ ${e.message}`));
     if (p) console.log(`  ✓ project added: ${p.name}  (${p.path})`);
     if (running || electron) process.exit(0);
   } else if (words.length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wisp-agents",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Launch coding agents, skip the transcript, read the presentation.",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
     "app": "node bin/wisp.js",
     "dev": "WISP_DEV=1 node bin/wisp.js",
     "dev:web": "node --watch-path=server bin/wisp.js --no-open",
-    "test": "node --test test/proc.test.js test/terminal.test.js test/adapters.test.js test/e2e.test.js test/fuzzy.test.js test/integrations.test.js test/update.test.js test/learn.test.js test/ship.test.js test/subagents.test.js test/machines.test.js test/feedback.test.js test/router.test.js test/routes.test.js test/adapters-exit.test.js test/web-pure.test.js test/install.test.js test/install-script.test.js test/mentions.test.js",
+    "test": "node --test test/proc.test.js test/terminal.test.js test/adapters.test.js test/e2e.test.js test/fuzzy.test.js test/integrations.test.js test/update.test.js test/learn.test.js test/ship.test.js test/subagents.test.js test/machines.test.js test/feedback.test.js test/router.test.js test/routes.test.js test/adapters-exit.test.js test/web-pure.test.js test/install.test.js test/install-script.test.js test/mentions.test.js test/clone.test.js",
     "test:real": "node test/real-clis.mjs",
     "prepublishOnly": "node --check bin/wisp.js && node --check bin/mac-app.js && node -e \"import('./server/index.js').then(() => import('./server/mcp-wisp.js'))\" && node --check electron/main.js"
   },

package/server/git.js

@@ -129,7 +129,7 @@ export async function removeWorktree(wt, { force = false, branch = false } = {})
 
 // --- Ship it: commit, push, open a PR, follow it, merge it -----------------------------------
 
-const PR_FIELDS = 'number,url,title,state,isDraft,reviewDecision,mergeStateStatus,statusCheckRollup,headRefOid,baseRefName,mergedAt';
+const PR_FIELDS = 'number,url,title,state,isDraft,reviewDecision,mergeable,mergeStateStatus,statusCheckRollup,headRefOid,baseRefName,mergedAt';
 const PASS = new Set(['SUCCESS', 'NEUTRAL', 'SKIPPED']);
 const FAIL = new Set(['FAILURE', 'ERROR', 'TIMED_OUT', 'CANCELLED', 'ACTION_REQUIRED', 'STARTUP_FAILURE', 'STALE']);
 
@@ -149,6 +149,8 @@ export function prSummary(j) {
     draft: !!j.isDraft,
     review: j.reviewDecision || '', // APPROVED | CHANGES_REQUESTED | REVIEW_REQUIRED | ''
     mergeState: j.mergeStateStatus || '',
+    // GitHub can't merge it into its base: both sides changed the same lines (UNKNOWN while it computes).
+    conflict: j.mergeable === 'CONFLICTING' || j.mergeStateStatus === 'DIRTY',
     head: j.headRefOid,
     base: j.baseRefName,
     mergedAt: j.mergedAt || null,
@@ -162,23 +164,58 @@ export async function prView(cwd, ref) {
 }
 
 // Commit whatever the session left uncommitted, push its branch and open (or update) its PR.
-export async function ship(wt, { title, body = '', draft = false, pr }) {
+// `onStep` hears each stage as it starts ('commit', 'push', 'pr'), so the card can follow along.
+export async function ship(wt, { title, body = '', draft = false, pr, onStep = () => {} }) {
   await ensureWorktree(wt);
   const dir = wt.path;
   if (await quiet(git(dir, ['status', '--porcelain']))) {
     if (!String(title || '').trim()) throw bad('A commit message is required.');
+    onStep('commit');
     await git(dir, ['add', '-A']);
     await git(dir, ['commit', '--quiet', '--no-verify', '-m', title.trim(), ...(body.trim() ? ['-m', body.trim()] : [])]);
   }
   const { ahead } = await worktreeStatus(wt);
   if (!ahead) throw bad('Nothing to ship: this branch has no changes.');
   if (!wt.remote) throw bad('This repo has no origin remote to push to.');
+  onStep('push');
   await git(dir, ['push', '--quiet', '-u', wt.remote, `HEAD:refs/heads/${wt.branch}`], { timeout: 120_000 });
+  onStep('pr');
   if (pr?.state === 'OPEN') return prView(dir, pr.number);
   const url = (await gh(dir, ['pr', 'create', '--base', wt.base, '--head', wt.branch, '--title', title.trim(), '--body', body.trim() || ' ', ...(draft ? ['--draft'] : [])])).split('\n').pop();
   return prView(dir, url);
 }
 
+// Does the branch really conflict with its freshly fetched base? Checked before spending an agent
+// run on GitHub's word, which can lag a push. true / false, or null when this git can't tell (< 2.38).
+export async function conflictsWithBase(wt) {
+  if (!wt?.remote || !fs.existsSync(wt.path)) return null;
+  await quiet(git(wt.path, ['fetch', '--quiet', wt.remote, wt.base], { timeout: 30_000 }));
+  return new Promise((resolve) => {
+    execFile(GIT(), ['merge-tree', '--write-tree', '--name-only', '--no-messages', `refs/remotes/${wt.remote}/${wt.base}`, 'HEAD'], { cwd: wt.path, timeout: 30_000, env: { ...process.env, ...QUIET_ENV } }, (err) =>
+      resolve(!err ? false : err.code === 1 ? true : null),
+    );
+  });
+}
+
+// After an agent was asked to merge the base into its branch: is it in, with nothing left half
+// done? A merge it resolved but left uncommitted is committed here. { ok } or { ok: false, why }.
+export async function baseMerged(wt) {
+  const dir = wt.path;
+  const unmerged = await quiet(git(dir, ['diff', '--name-only', '--diff-filter=U']));
+  if (unmerged) return { ok: false, why: `Still conflicted: ${unmerged.split('\n').join(', ')}` };
+  if (await quiet(git(dir, ['rev-parse', '--quiet', '--verify', 'MERGE_HEAD']))) {
+    await git(dir, ['add', '-A']);
+    await git(dir, ['commit', '--quiet', '--no-verify', '--no-edit']);
+  }
+  const base = `refs/remotes/${wt.remote}/${wt.base}`;
+  const merged = await git(dir, ['merge-base', '--is-ancestor', base, 'HEAD']).then(() => true, () => false);
+  if (!merged) return { ok: false, why: `${wt.remote}/${wt.base} is not merged into the branch.` };
+  // Conflict markers staged as if resolved: git no longer sees them, so look in the PR's diff.
+  const marked = await quiet(git(dir, ['diff', '--name-only', '-G^<<<<<<< ', `${base}...HEAD`]));
+  if (marked) return { ok: false, why: `Conflict markers left in ${marked.split('\n').join(', ')}` };
+  return { ok: true };
+}
+
 // Squash-merge the exact head that was reviewed, then tidy up and catch the user's checkout up.
 export async function merge(wt, number) {
   const dir = fs.existsSync(wt.path) ? wt.path : wt.root;
@@ -205,3 +242,78 @@ export async function syncBase(root, base) {
     return { ok: false, text: `Local ${base} was not updated: ${err.message}` };
   }
 }
+
+// --- cloning: "add a project" from a repo URL instead of a folder ---
+
+// A repo the user pasted: https://github.com/o/r(/tree/…), github.com/o/r, git@host:o/r.git,
+// ssh:// git:// file:// URLs, and (shorthand) o/r for GitHub. Null when it's not a repo, e.g. a path.
+export function parseRepo(input, { shorthand = false } = {}) {
+  const s = String(input || '').trim();
+  const strip = (p) => p.replace(/\/+$/, '').replace(/\.git$/i, '');
+  const of = (url, host, repoPath) => {
+    const parts = strip(repoPath).split('/').filter(Boolean);
+    if (!parts.length) return null;
+    const gh = host === 'github.com' && parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
+    return { url, host, name: gh ? parts[1] : parts.at(-1), gh, path: parts.join('/') };
+  };
+  let m;
+  if (/^(https?|ssh|git|file):\/\//i.test(s) || /^(www\.)?github\.com\//i.test(s)) {
+    let u;
+    try {
+      u = new URL(/^\w+:\/\//.test(s) ? s : `https://${s}`);
+    } catch {
+      return null;
+    }
+    const host = u.hostname.replace(/^www\./, '').toLowerCase();
+    if (u.protocol === 'file:') return of(u.href, '', u.pathname);
+    if (!host) return null;
+    // A GitHub page inside the repo (/tree/main, /pull/3) still means the repo.
+    if (host === 'github.com') {
+      const [o, r] = u.pathname.split('/').filter(Boolean);
+      return o && r ? of(`https://github.com/${o}/${strip(r)}.git`, host, `${o}/${r}`) : null;
+    }
+    return u.pathname.split('/').filter(Boolean).length >= 2 || u.protocol !== 'https:' ? of(s, host, u.pathname) : null;
+  }
+  if ((m = s.match(/^[\w.-]+@([\w.-]+):(?!\/\/)(.+)$/))) return of(s, m[1].toLowerCase(), m[2]);
+  if (shorthand && (m = s.match(/^([\w-]+)\/([\w.-]+)$/))) return of(`https://github.com/${m[1]}/${strip(m[2])}.git`, 'github.com', `${m[1]}/${m[2]}`);
+  return null;
+}
+
+// The same repo, however it was spelled (https vs ssh, .git or not, case of the host).
+const sameRepo = (a, b) => {
+  const key = (u) => {
+    const r = parseRepo(u);
+    return r && (r.gh ? `github.com/${r.gh.toLowerCase()}` : `${r.host}/${r.path}`);
+  };
+  return !!key(a) && key(a) === key(b);
+};
+
+// Clone `repo` (from parseRepo) into `parent`/<name>. A folder there that already is this repo is
+// reused; any other one gets a -2, -3… suffix. GitHub repos go through `gh repo clone` when gh is
+// there, so private repos work with the user's gh login; otherwise (or if gh fails) plain git.
+export async function cloneRepo(repo, parent, { timeout = 10 * 60_000 } = {}) {
+  fs.mkdirSync(parent, { recursive: true });
+  let dir = path.join(parent, repo.name);
+  for (let n = 2; fs.existsSync(dir); n++) {
+    const origin = await quiet(git(dir, ['remote', 'get-url', 'origin']));
+    if (origin && (await repoRoot(dir)) === fs.realpathSync(dir) && sameRepo(origin, repo.url)) return { dir, existed: true };
+    dir = path.join(parent, `${repo.name}-${n}`);
+  }
+  const attempts = [];
+  if (repo.gh) attempts.push(() => gh(parent, ['repo', 'clone', repo.gh, dir], { timeout }));
+  attempts.push(() => run(GIT(), ['clone', '--quiet', repo.url, dir], { cwd: parent, timeout }));
+  let last;
+  for (const attempt of attempts) {
+    try {
+      await attempt();
+      return { dir, existed: false };
+    } catch (err) {
+      last = err;
+      fs.rmSync(dir, { recursive: true, force: true }); // a half clone would block the next try
+    }
+  }
+  const what = repo.gh || repo.url;
+  if (/not found|does not exist|could not read username|authentication|permission denied|403/i.test(last.message))
+    throw bad(`Couldn’t clone ${what}: it doesn’t exist, or this login can’t see it.${repo.gh ? ' Private repo? Check `gh auth status`.' : ''}`);
+  throw bad(`Couldn’t clone ${what}: ${last.message}`);
+}

package/server/machines.js

@@ -500,7 +500,7 @@ export class Machines extends EventEmitter {
   summary(mid, s) {
     const m = this.get(mid);
     const q = (id) => qualify(id, mid);
-    const p = this.store.projectFor(s.cwd || '', mid);
+    const p = s.scratch ? null : this.store.projectFor(s.cwd || '', mid);
     return {
       ...s,
       id: q(s.id),
@@ -578,7 +578,7 @@ export class Machines extends EventEmitter {
   }
 
   async addProject(mid, dir, name) {
-    const p = await this.json(mid, 'POST', '/projects', { path: dir });
+    const p = await this.json(mid, 'POST', '/projects', { path: dir }, { timeout: 10 * 60_000 }); // dir may be a repo URL to clone
     const local = this.store.addProject(p.path, { name: name || p.name, machine: mid });
     return local;
   }

package/server/openapi.js

@@ -90,7 +90,19 @@ export function openapi({ version, port }) {
       },
       '/projects': {
         get: { summary: 'List projects', responses: { 200: json({ type: 'array', items: ref('Project') }) } },
-        post: { summary: 'Add a folder as a project', requestBody: body({ type: 'object', required: ['path'], properties: { path: { type: 'string' }, name: { type: 'string' } } }), responses: { 201: json(ref('Project')), 400: err[400] } },
+        post: {
+          summary: 'Add a folder as a project, or clone a repo URL and add the clone',
+          requestBody: body({
+            type: 'object',
+            properties: {
+              path: { type: 'string', description: 'A folder, or a repo URL (https://github.com/o/r, git@host:o/r.git, o/r)' },
+              repo: { type: 'string', description: 'A repo URL to clone into defaults.cloneDir (default ~/code), then add' },
+              name: { type: 'string' },
+              machine: { type: 'string', description: 'Add (or clone) it on this machine' },
+            },
+          }),
+          responses: { 201: json(ref('Project')), 400: err[400] },
+        },
       },
       '/projects/{pid}': {
         parameters: [{ name: 'pid', in: 'path', required: true, schema: { type: 'string' } }],
@@ -132,6 +144,7 @@ export function openapi({ version, port }) {
         },
       },
       '/sessions/{id}/pr': { parameters: [id], post: { summary: 'Refresh the PR status (checks, review, state) now; it is also polled every minute', responses: { 200: json(ref('PullRequest')), 404: err[404] } } },
+      '/sessions/{id}/fix-conflicts': { parameters: [id], post: { summary: 'Retry the automatic merge-conflict fix after it gave up: a follow-up merges the base in, then wisp pushes to the PR', responses: { 200: json({ type: 'object' }), 400: err[400] } } },
       '/sessions/{id}/merge': {
         parameters: [id],
         post: { summary: 'Mark the PR ready if draft, squash-merge it with --match-head-commit, fast-forward the local base branch, remove the worktree', responses: { 200: json({ type: 'object', properties: { pr: ref('PullRequest'), sync: { type: 'object', properties: { ok: { type: 'boolean' }, text: { type: 'string' } } } } }), 400: err[400] } },
@@ -291,6 +304,7 @@ export function openapi({ version, port }) {
           properties: {
             prompt: { type: 'string' },
             cwd: { type: 'string', description: 'Project folder (absolute; ~ allowed). Default: the server’s cwd' },
+            scratch: { type: 'boolean', description: 'No project folder: run in an empty scratch directory (no worktree). Overrides cwd' },
             agent: { enum: ['auto', 'claude', 'codex', 'opencode', 'cursor', 'antigravity', 'grok'], default: 'auto', description: 'auto: wisp picks the harness and model from what worked before; model is then the goal (cheap, balanced, best)' },
             important: { type: 'boolean', description: 'With agent auto: no exploring, take the pick with the best record' },
             mode: { enum: ['plan', 'edits', 'auto'], default: 'auto' },
@@ -312,6 +326,7 @@ export function openapi({ version, port }) {
             draft: { type: 'boolean' },
             review: { type: 'string', description: 'APPROVED | CHANGES_REQUESTED | REVIEW_REQUIRED | ""' },
             checks: { type: 'object', properties: { pass: { type: 'integer' }, fail: { type: 'integer' }, pending: { type: 'integer' } } },
+            conflict: { type: 'boolean', description: 'GitHub cannot merge it into its base: merge conflicts' },
             head: { type: 'string' },
             base: { type: 'string' },
           },
@@ -393,6 +408,8 @@ export function openapi({ version, port }) {
             updatedAt: { type: 'integer' },
             branch: { type: 'string', description: 'Worktree branch, if it has one' },
             pr: { type: ['object', 'null'], description: 'Its pull request, once shipped' },
+            shipping: { type: ['object', 'null'], description: "{ step: start | commit | push | pr, update } while Ship it runs" },
+            conflictFix: { type: ['object', 'null'], description: "{ step: fixing | pushing | done | failed, why } while wisp fixes the PR's merge conflicts on its own (defaults.fixConflicts: 'off' turns it off)" },
             groupId: { type: ['string', 'null'], description: 'Shared by sessions launched together with compare' },
             origin: { type: ['object', 'null'], description: '{ kind: recipe | trigger, id, name } when not launched by hand' },
           },

package/server/routes/meta.js

@@ -34,7 +34,7 @@ export function register(r, app) {
 
   r.route('GET', '/openapi.json', (c) => c.send(200, openapi({ version: VERSION, port })), { doc: false });
 
-  r.route('GET', '/agents', async (c) => c.send(200, await app.auto.detect({ fresh: c.query.has('fresh') })));
+  r.route('GET', '/agents', async (c) => c.send(200, await (c.query.has('fresh') ? app.auto.detect({ fresh: true }) : app.auto.listed())));
   // Re-check: detect harnesses and models again, here and on every online machine.
   r.route('POST', '/agents/recheck', async (c) => {
     const [agents] = await Promise.all([app.auto.detect({ fresh: true }), machines.recheckAgents()]);

package/server/routes/settings.js

@@ -9,16 +9,27 @@ import { normalizePreset } from '../subagents.js';
 import { envDisabled, feedbackAvailable } from '../telemetry.js';
 import { TERMINALS } from '../terminal.js';
 import { normalizeWebhooks } from '../services/webhooks.js';
+import { cloneRepo, gh, git, parseRepo } from '../git.js';
 import { expand } from '../util.js';
 
 // Where people keep their repos, for one-click "add project".
 const REPO_ROOTS = ['code', 'Code', 'dev', 'Developer', 'projects', 'Projects', 'src', 'repos', 'work', 'git', 'GitHub', 'Documents', 'Downloads', 'Desktop'];
 
+// Where a pasted repo URL is cloned: defaults.cloneDir, else the first usual repo folder that
+// exists (not Documents/Downloads/Desktop), else ~/code.
+export function cloneRoot(config) {
+  if (config.defaults?.cloneDir) return expand(config.defaults.cloneDir);
+  const dir = REPO_ROOTS.slice(0, -3)
+    .map((r) => path.join(os.homedir(), r))
+    .find((d) => fs.existsSync(d) && fs.statSync(d).isDirectory());
+  return dir || path.join(os.homedir(), 'code');
+}
+
 export function register(r, app) {
   const { store, telemetry, prefs, retro, remote, machines } = app;
 
   r.route('GET', '/config', (c) =>
-    c.send(200, { ...store.config, remote: undefined, home: os.homedir(), cwd: process.cwd(), terminals: TERMINALS, telemetry: { available: !envDisabled(), enabled: telemetry.enabled }, feedback: feedbackAvailable() }),
+    c.send(200, { ...store.config, remote: undefined, home: os.homedir(), cwd: process.cwd(), cloneDir: cloneRoot(store.config), terminals: TERMINALS, telemetry: { available: !envDisabled(), enabled: telemetry.enabled }, feedback: feedbackAvailable() }),
   );
   r.route('PATCH', '/config', async (c) => {
     const body = await c.body();
@@ -91,18 +102,54 @@ export function register(r, app) {
   r.route('POST', '/projects', async (c) => {
     const body = await c.body();
     if (body.machine) {
-      const p = await machines.addProject(String(body.machine), String(body.path || '').trim(), body.name);
+      const p = await machines.addProject(String(body.machine), String(body.repo || body.path || '').trim(), body.name);
       app.broadcast('config', {});
       return c.send(201, p);
     }
-    const dir = expand(body.path || '');
+    // A repo URL (in `repo`, or pasted into `path`): clone it, then add the clone.
+    const typed = String(body.repo || body.path || '').trim();
+    const local = !body.repo && (/^[~./\\]|^[a-z]:/i.test(typed) || fs.existsSync(expand(typed)));
+    const repo = !local && parseRepo(typed, { shorthand: true });
+    if (body.repo && !repo) return c.send(400, { error: `Not a repo URL: ${typed}` });
+    let dir = expand(typed);
+    let cloned = null;
+    if (repo) {
+      const out = await cloneRepo(repo, cloneRoot(store.config));
+      dir = out.dir;
+      cloned = { url: repo.url, existed: out.existed };
+    }
     if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) return c.send(400, { error: `Not a folder: ${dir}` });
     const p = store.addProject(dir, { name: body.name });
     app.broadcast('config', {});
-    c.send(201, p);
+    c.send(201, cloned ? { ...p, cloned } : p);
   });
   // Find git repos in the usual places so adding projects is one click.
   r.route('GET', '/projects/discover', (c) => c.send(200, discoverRepos(new Set(store.config.projects.map((p) => p.path)))), { doc: false });
+  // The user's GitHub repos (gh's login), newest first, minus ones already added: one click clones.
+  // Empty when gh isn't installed or signed in.
+  r.route(
+    'GET',
+    '/projects/github',
+    async (c) => {
+      const list = await gh(os.homedir(), ['repo', 'list', '--limit', '40', '--json', 'nameWithOwner,description,isPrivate,isFork,pushedAt,url'], { timeout: 20_000 })
+        .then((out) => JSON.parse(out || '[]'))
+        .catch(() => null);
+      if (!list) return c.send(200, []);
+      const origins = await Promise.all(
+        store.config.projects.filter((p) => !p.machine).map((p) => git(p.path, ['remote', 'get-url', 'origin'], { timeout: 5000 }).catch(() => '')),
+      );
+      const have = new Set(origins.map((o) => parseRepo(o)?.gh?.toLowerCase()).filter(Boolean));
+      c.send(
+        200,
+        list
+          .filter((x) => !have.has(x.nameWithOwner.toLowerCase()))
+          .sort((a, b) => String(b.pushedAt).localeCompare(String(a.pushedAt)))
+          .slice(0, 24)
+          .map((x) => ({ repo: x.nameWithOwner, url: x.url, description: x.description || '', private: !!x.isPrivate, fork: !!x.isFork, pushedAt: x.pushedAt })),
+      );
+    },
+    { doc: false },
+  );
   const project = (c) => store.config.projects.find((x) => x.id === c.params.id);
   r.route('PATCH', '/projects/:id', async (c) => {
     const p = project(c);

package/server/routes/ship.js

@@ -27,11 +27,20 @@ export function register(r, app) {
     one(async (c, s) => {
       if (!s.worktree) return c.send(400, { error: NO_TREE });
       if (runner.live.has(s.id)) return c.send(409, { error: 'Still working: wait for it to finish, or stop it.' });
+      if (s.shipping) return c.send(409, { error: 'Already shipping: wait for it to land.' });
       const body = await c.body();
       const draft = app.ship.draft(s);
-      s.pr = await ship(s.worktree, { title: body.title ?? draft.title, body: body.body ?? draft.body, draft: !!body.draft, pr: s.pr });
+      // The card follows along: s.shipping names the stage running now, sent with each summary.
+      s.shipping = { step: 'start', update: s.pr?.state === 'OPEN', startedAt: Date.now() };
+      app.sessionChanged(s);
+      const onStep = (step) => ((s.shipping = { ...s.shipping, step }), app.sessionChanged(s));
+      try {
+        s.pr = await ship(s.worktree, { title: body.title ?? draft.title, body: body.body ?? draft.body, draft: !!body.draft, pr: s.pr, onStep });
+      } finally {
+        delete s.shipping;
+        app.sessionChanged(s, { now: true });
+      }
       telemetry.track('ship', { agent: s.agent, draft: !!body.draft });
-      app.sessionChanged(s, { now: true });
       app.ship.recheck(s);
       c.send(200, s.pr);
     }),
@@ -44,6 +53,19 @@ export function register(r, app) {
       c.send(200, await app.ship.refreshPr(s));
     }),
   );
+  // Try the automatic conflict fix again after it gave up (see services/ship.js).
+  r.route(
+    'POST',
+    '/sessions/:id/fix-conflicts',
+    one(async (c, s) => {
+      if (s.pr?.state !== 'OPEN' || !s.worktree) return c.send(400, { error: 'No open pull request.' });
+      if (runner.live.has(s.id)) return c.send(409, { error: 'Still working: wait for it to finish, or stop it.' });
+      s.conflictFix = { tries: 0 };
+      await app.ship.refreshPr(s);
+      if (s.conflictFix?.step !== 'fixing') return c.send(409, { error: s.pr.conflict ? 'It merges cleanly with the latest base here: GitHub may not have caught up yet.' : 'The PR has no merge conflicts now.' });
+      c.send(200, { conflictFix: s.conflictFix });
+    }),
+  );
   // Squash-merge the reviewed head, sync the user's base branch, clean up the worktree.
   r.route(
     'POST',

package/server/runner.js

@@ -81,7 +81,8 @@ export function summarize(s, store) {
     title: s.title,
     agent: s.agent,
     cwd: s.cwd,
-    project: s.agent === 'wisp' ? 'tour' : project?.name || path.basename(s.cwd || ''),
+    scratch: store?.isScratch?.(s.cwd) || undefined,
+    project: s.agent === 'wisp' ? 'tour' : (store?.isScratch?.(s.cwd) ? 'General' : project?.name) || path.basename(s.cwd || ''),
     projectId: project?.id || null,
     color: project?.color || 'slate',
     mode: s.mode,
@@ -102,7 +103,10 @@ export function summarize(s, store) {
     approval: !!s.ask?.permission, // the question is a live approval (Allow / Deny)
     branch: s.worktree?.branch || '',
     toShip: s.toShip || null, // { dirty, ahead, unpushed } of the worktree, null until checked
-    pr: s.pr ? { number: s.pr.number, url: s.pr.url, state: s.pr.state, draft: s.pr.draft, review: s.pr.review, checks: s.pr.checks } : null,
+    shipping: s.shipping || null, // { step: 'start' | 'commit' | 'push' | 'pr', update } while Ship it runs
+    pr: s.pr ? { number: s.pr.number, url: s.pr.url, state: s.pr.state, draft: s.pr.draft, review: s.pr.review, checks: s.pr.checks, conflict: !!s.pr.conflict } : null,
+    // wisp fixing the PR's merge conflicts on its own: { step: 'fixing' | 'pushing' | 'done' | 'failed', why }
+    conflictFix: s.conflictFix ? { step: s.conflictFix.step, why: s.conflictFix.why || '' } : null,
     groupId: s.groupId || null,
     origin: s.origin || null, // { kind: 'recipe' | 'trigger' | 'telegram', id, name }
     // The roster, for the stacked logos on the card: used = delegated to at least once, busy = working now.

package/server/services/auto.js

@@ -19,6 +19,17 @@ export function createAuto(app) {
   };
   // This computer's harnesses: the last ones detected, else detected now.
   const agents = async () => (agentsHere.length ? agentsHere : await detect());
+  // What the page asks for on every load: the last detection right away, checked again in the
+  // background (a cold probe takes seconds: opencode lists its models), and an 'agents' event
+  // if that changed anything, so the launcher never waits on it.
+  const listed = async () => {
+    if (!agentsHere.length) return detect();
+    const before = JSON.stringify(agentsHere);
+    detect()
+      .then((now) => JSON.stringify(now) !== before && app.broadcast('agents', {}))
+      .catch(() => {});
+    return agentsHere;
+  };
 
   const opts = () => {
     const r = store.config.defaults.router || {};
@@ -63,5 +74,5 @@ export function createAuto(app) {
   // What the Auto view shows: goals, settings, and what the router learned.
   const view = async () => ({ goals: GOALS, goal: goalOf(), settings: { explore: opts().explore, allowed: opts().allowed }, ...router.report(await agents()) });
 
-  return { detect, agents, opts, goalOf, signals, resolve, view };
+  return { detect, agents, listed, opts, goalOf, signals, resolve, view };
 }

package/server/services/launch.js

@@ -15,11 +15,13 @@ export const MAX_COMPARE = 4;
 export function createLaunch(app) {
   const { store, runner, machines } = app;
 
-  // body: { prompt, cwd, agent, mode, model, effort, attachments: [uploadId], worktree, compare,
+  // body: { prompt, cwd, scratch: true = no folder, agent, mode, model, effort, attachments: [uploadId], worktree, compare,
   //         subagents: [{ name, agent, model, effort, use }] | preset: teamId }
   async function launch(body, origin = null) {
     if (!String(body.prompt || '').trim()) throw bad('prompt required');
-    const cwd = expand(body.cwd || process.cwd());
+    // scratch: no project folder (general questions); the task gets an empty directory of its own.
+    const scratch = body.scratch === true;
+    const cwd = scratch ? store.scratchDir(newId()) : expand(body.cwd || process.cwd());
     if (!fs.existsSync(cwd) || !fs.statSync(cwd).isDirectory()) throw bad(`Not a directory: ${cwd}`);
     const d = store.config.defaults;
     const preset = body.preset && store.config.teams.find((t) => t.id === body.preset);
@@ -37,7 +39,7 @@ export function createLaunch(app) {
     // Worktrees are on by default in git repos (off in Plan mode: nothing gets written). Compare
     // runs need one each, or the harnesses would edit the same files.
     const comparing = runners.length > 1;
-    const wantTree = body.worktree ?? (comparing || (mode !== 'plan' && d.worktree !== 'off'));
+    const wantTree = !scratch && (body.worktree ?? (comparing || (mode !== 'plan' && d.worktree !== 'off')));
     // groupId: one launch sent to several machines (or here and there) shows as one task.
     const groupId = /^[a-f0-9]{12}$/.test(body.groupId || '') ? body.groupId : comparing ? newId() : null;
     const attachments = app.uploads.resolve(body.attachments);
@@ -92,10 +94,12 @@ export function createLaunch(app) {
     if (!sendBody.compare?.length && !body.compare) delete sendBody.compare;
     const out = await machines.launch(mid, { ...sendBody, attachments: await pushUploads(mid, body.attachments), ...(origin && { origin }) });
     (out.group || [out]).forEach((x, i) => routes[i] && app.router.record(qualify(x.id, mid), routes[i]));
-    const known = store.projectFor(out.cwd, mid);
-    (known || store.addProject(out.cwd, { machine: mid })).lastUsedAt = Date.now();
-    store.saveConfig();
-    if (!known) app.broadcast('config', {});
+    const known = out.scratch || store.projectFor(out.cwd, mid);
+    if (!out.scratch) {
+      (known || store.addProject(out.cwd, { machine: mid })).lastUsedAt = Date.now();
+      store.saveConfig();
+      if (!known) app.broadcast('config', {});
+    }
     return (out.group || [out]).map((x) => machines.summary(mid, x));
   }