@ulysses-ai/create-workspace 0.19.0-beta.0 → 0.20.0-beta.0

package/template/_claude/scripts/task-pr.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-// PR creation and merge for the task lifecycle (gh:163).
+// PR creation and merge for the task lifecycle (gh:163), including local
+// mode for repos with no forge to push to (gh:173).
 //
 // The task path of /complete-work used to end with two hand-written
 // JavaScript blocks — one to push and open a PR per repo, one to merge them
@@ -16,41 +17,67 @@
 // Usage:
 //   node task-pr.mjs --create --root <launcher> --branch <branch>
 //                    [--work-item gh:N] [--chat <name> | --repo <r> ...]
-//                    --body-file <repo>=<path> ... [--out <file>]
+//                    --body-file <forge-repo>=<path> ... [--out <file>]
 //                    [--force-with-lease]
 //   node task-pr.mjs --merge --root <launcher> --prs <json-from-create>
 //                    [--work-item gh:N]
 //
+// Every repo of the task resolves to a merge mode (mergeModeFor below):
+// "forge" — its origin is a forge-hosted owner/name — or "local" — no
+// origin at all, or an explicit "local" override in workspace.json
+// (repos.{repo}.merge / workspace.merge), the escape hatch for a clone
+// whose origin is a third-party upstream nobody here may push to. An
+// origin that is neither stops the run with the override spelled out.
+//
 // --create resolves the task's repos from the chat record's entries for
 // the branch (--chat) or from repeated --repo flags, skips repos whose
-// branch has no commits over origin/{default} (reported as empty), pushes
-// each remaining branch, and opens one PR per repo through a per-repo
-// forge. The PR title is the linked issue's title when --work-item is
-// given, else the branch's first commit subject; the body is the repo's
-// body file with `Closes <ref>` appended. Prints `{ prs, empty, pushed }`
-// and, with --out, writes the same JSON to a file — a mid-run failure
-// still writes what has landed so far, so the state survives the error.
-// A repo that already has an open PR for the branch gets it reused, so a
-// re-run never opens a duplicate.
+// branch has no commits over the base — origin/{default} for a forge
+// repo, the local {default} for a local repo, whose origin ref never
+// advances — (reported as empty), pushes each remaining forge branch, and
+// opens one PR per forge repo through a per-repo forge — a local repo is
+// neither pushed nor PR'd, only recorded as a local entry for --merge (a
+// body file is required per forge repo alone; one given for a local repo
+// is ignored). The PR title is the linked issue's title when --work-item
+// is given, else the branch's first commit subject; the body is the
+// repo's body file with `Closes <ref>` appended. Prints
+// `{ prs, empty, pushed }` — prs holds forge entries (mode "forge") and
+// local entries (mode "local") alike, every entry carrying its commit
+// count — and, with --out, writes the same JSON to a file — a mid-run
+// failure still writes what has landed so far, so the state survives the
+// error. A repo that already has an open PR for the branch gets it
+// reused, so a re-run never opens a duplicate.
 //
-// --merge merges the project PRs first (squash, delete branch), the
-// workspace PR only when every project merge succeeded — a PR the forge
-// reports as already MERGED counts as done and is not merged again, which
-// is what makes re-running after a partial failure safe. An empty or
-// malformed PRs file is refused outright: no PRs means nothing to merge
-// and nothing to close. Once every PR is merged the launcher is pulled
+// --merge finishes every entry in the file: forge PRs first (squash,
+// delete branch) and local branches as a `git merge --ff-only` in the
+// repo's source clone — repos/{repo}, or the launcher itself for "." —
+// which must sit clean on its default branch, and whose task branch must
+// fast-forward or be rebased by hand. The project repos merge first, the
+// workspace repo only when every project merge succeeded; a PR the forge
+// reports as already MERGED and a local branch already contained in the
+// default branch both count as done, which is what makes re-running after
+// a partial failure safe. An empty or malformed PRs file — or one naming
+// a repo other than "." or a plain repo name, since a local entry's repo
+// becomes a path — is refused outright: no entries means nothing to merge
+// and nothing to close. Once everything is merged the launcher is pulled
 // --ff-only — only when it sits on the workspace default branch (else
-// pullSkipped), and a failed pull is reported as pullFailed in the JSON
-// rather than an error, because the merges stand and the issue still
-// closes — and then the linked issue closes with a Merged: comment. On a
-// merge failure it stops and names the PRs still open.
+// pullSkipped), never when "." was itself merged locally (the launcher
+// already has that work), when the workspace repo is local (no forge
+// merge happened that a pull could fetch), or when the launcher branch
+// has no upstream to pull from — pullSkipped names which — and a failed
+// pull is reported as pullFailed in the JSON rather than an error,
+// because the merges stand and the issue still closes — and then the
+// linked issue closes with a Merged: comment, but only when --work-item
+// is given AND a tracker is configured; with no tracker the JSON reports
+// closed: null and closeSkipped. On a merge failure it stops and names
+// what is still open.
 
 import '../lib/require-node.mjs';
 import { readFileSync, writeFileSync, mkdirSync, existsSync, realpathSync } from 'node:fs';
-import { join, resolve, dirname } from 'node:path';
+import { resolve, dirname } from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import { taskWorktreePath, defaultBranchFor, WORKSPACE_REPO } from './task-worktree.mjs';
+import { taskWorktreePath, defaultBranchFor } from './task-worktree.mjs';
+import { WORKSPACE_REPO, repoDirFor, readWorkspace, parseForgeRemote, mergeModeFor } from './merge-mode.mjs';
 import { readRecord } from './chat-record.mjs';
 import { createForge } from './forges/interface.mjs';
 import { createTracker } from './trackers/interface.mjs';
@@ -62,24 +89,6 @@ function isMainModule(metaUrl) {
   } catch { return false; }
 }
 
-// Same remote shapes the forge adapters resolve a repo from. A URL that
-// does not match is not forge-hosted, and this path supports forge-hosted
-// repos only — a local/bare remote has no PR concept to aim at.
-const FORGE_REMOTE_RE = /github\.com[:/]([^/]+)\/([^/.]+?)(?:\.git)?$/;
-
-function parseForgeRemote(url) {
-  const m = String(url).trim().match(FORGE_REMOTE_RE);
-  return m ? { owner: m[1], name: m[2] } : null;
-}
-
-function readWorkspace(rootDir) {
-  try {
-    return JSON.parse(readFileSync(join(rootDir, 'workspace.json'), 'utf-8'));
-  } catch {
-    throw new Error(`cannot read ${join(rootDir, 'workspace.json')} — is --root the launcher?`);
-  }
-}
-
 // `workspace.forge: false` is an explicit opt-out; spreading it into a
 // per-repo config would silently produce a default GitHub forge instead.
 function assertForgeEnabled(ws) {
@@ -123,29 +132,37 @@ function gitOut(gitFn, cwd, args) {
 }
 
 // The merge base for "is this branch empty" and for the fallback PR title.
-// origin/{default} is the truth the PR will merge against; the local branch
-// covers a repo whose remote-tracking ref is missing.
-function baseRefFor(gitFn, worktree, defaultBranch) {
-  for (const ref of [`origin/${defaultBranch}`, defaultBranch]) {
+// A forge repo counts against origin/{default} — the truth the PR will
+// merge against — with the local branch as the fallback for a repo whose
+// remote-tracking ref is missing. A local-mode repo counts against the
+// local {default}, where its merges actually land: its origin ref never
+// advances, so counting against it would re-count every already-merged
+// commit (and misjudge every follow-up task as non-empty).
+function baseRefFor(gitFn, target, branch) {
+  const { worktree, defaultBranch, mode } = target;
+  const refs = mode === 'local'
+    ? [defaultBranch, `origin/${defaultBranch}`]
+    : [`origin/${defaultBranch}`, defaultBranch];
+  for (const ref of refs) {
     if (gitCheck(gitFn, worktree, ['rev-parse', '--verify', '--quiet', ref]).status === 0) return ref;
   }
   return null;
 }
 
-function commitsOverBase(gitFn, worktree, branch, defaultBranch) {
-  const base = baseRefFor(gitFn, worktree, defaultBranch);
+function commitsOverBase(gitFn, target, branch) {
+  const base = baseRefFor(gitFn, target, branch);
   // No base ref at all: the branch cannot be proven empty, so it proceeds.
   if (!base) return null;
-  return parseInt(gitOut(gitFn, worktree, ['rev-list', '--count', `${base}..${branch}`]), 10) || 0;
+  return parseInt(gitOut(gitFn, target.worktree, ['rev-list', '--count', `${base}..${branch}`]), 10) || 0;
 }
 
-function firstCommitSubject(gitFn, worktree, branch, defaultBranch) {
-  const base = baseRefFor(gitFn, worktree, defaultBranch);
+function firstCommitSubject(gitFn, target, branch) {
+  const base = baseRefFor(gitFn, target, branch);
   const range = base ? `${base}..${branch}` : branch;
-  const subjects = gitOut(gitFn, worktree, ['log', '--reverse', '--format=%s', range])
+  const subjects = gitOut(gitFn, target.worktree, ['log', '--reverse', '--format=%s', range])
     .split(/\r?\n/).filter((l) => l.trim() !== '');
   if (subjects.length > 0) return subjects[0].trim();
-  return gitOut(gitFn, worktree, ['log', '-1', '--format=%s', branch]);
+  return gitOut(gitFn, target.worktree, ['log', '-1', '--format=%s', branch]);
 }
 
 function pushBranch(gitFn, worktree, repo, branch, { forceWithLease = false } = {}) {
@@ -182,7 +199,6 @@ async function createPrs(args, deps) {
   assertBranchName(deps.gitFn, args.branch);
   const rootDir = resolve(args.root);
   const ws = readWorkspace(rootDir);
-  assertForgeEnabled(ws);
 
   const targets = resolveTaskRepos(rootDir, args).map((repo) => {
     const worktree = taskWorktreePath(rootDir, repo, args.branch);
@@ -195,22 +211,34 @@ async function createPrs(args, deps) {
     };
   });
 
-  for (const t of targets) t.commits = commitsOverBase(deps.gitFn, t.worktree, args.branch, t.defaultBranch);
+  // Mode first, because the commit count itself depends on it: a local
+  // repo counts against its local default branch, not the origin ref that
+  // never advances (gh:173).
+  for (const t of targets) t.mode = mergeModeFor(rootDir, t.repo, { gitFn: deps.gitFn });
+  for (const t of targets) t.commits = commitsOverBase(deps.gitFn, t, args.branch);
   const empty = targets.filter((t) => t.commits === 0).map((t) => t.repo);
   const active = targets.filter((t) => t.commits !== 0);
 
-  // Every guard runs before the first push: a repo whose origin cannot
-  // host a PR, or whose body file is missing, must stop the whole task
-  // with nothing pushed and nothing half-opened.
+  // Every guard runs before the first push: a repo whose origin can neither
+  // host a PR nor opt out with "local", or whose body file is missing, must
+  // stop the whole task with nothing pushed and nothing half-opened. The
+  // same pass splits the task: local repos are recorded for --merge instead
+  // of being pushed. An empty repo is exempt from the origin check — there
+  // is nothing to merge however its remote is shaped.
   for (const t of active) {
+    if (t.mode !== null) continue;
     const url = gitOut(deps.gitFn, t.worktree, ['remote', 'get-url', 'origin']);
-    const parsed = parseForgeRemote(url);
-    if (!parsed) {
-      throw new Error(`repo "${t.repo}": origin (${url}) is not a forge-hosted repository — stopped before pushing anything. Complete this repo under the session model.`);
-    }
-    Object.assign(t, parsed);
+    const setting = t.isWorkspace ? 'workspace.merge' : `repos.${t.repo}.merge`;
+    throw new Error(`repo "${t.repo}": origin (${url}) is not a forge-hosted repository — stopped before pushing anything. Set ${setting} to "local" in workspace.json to merge this repo without a forge, or complete it under the session model.`);
   }
-  for (const t of active) {
+  const forgeActive = active.filter((t) => t.mode === 'forge');
+  // Only the forge half of the task needs a forge; an all-local task must
+  // still complete with forge operations disabled.
+  if (forgeActive.length > 0) assertForgeEnabled(ws);
+  for (const t of forgeActive) {
+    Object.assign(t, parseForgeRemote(gitOut(deps.gitFn, t.worktree, ['remote', 'get-url', 'origin'])));
+  }
+  for (const t of forgeActive) {
     const bodyFile = args.bodyFiles.get(t.repo);
     if (!bodyFile) {
       throw new Error(`repo "${t.repo}" has commits to merge but no --body-file — one is required for every repo that gets a PR`);
@@ -222,21 +250,29 @@ async function createPrs(args, deps) {
 
   let issueTitle = null;
   let issueRefs = null;
-  if (args.workItem) {
-    const tracker = deps.trackerFactory(ws.workspace?.tracker);
+  if (args.workItem && ws.workspace?.tracker) {
+    const tracker = deps.trackerFactory(ws.workspace.tracker);
     issueTitle = (await tracker.getIssue(args.workItem)).title;
-    issueRefs = new Map(active.map((t) => [t.repo, tracker.issueRef(args.workItem, { fromRepo: `${t.owner}/${t.name}` })]));
+    issueRefs = new Map(forgeActive.map((t) => [t.repo, tracker.issueRef(args.workItem, { fromRepo: `${t.owner}/${t.name}` })]));
   }
 
-  const prs = [];
+  // Local entries are recorded up front, before anything can fail: they are
+  // the run's only side effect for those repos, and losing one to a later
+  // forge failure would leave --merge unable to finish the task.
+  const prs = active
+    .filter((t) => t.mode === 'local')
+    .map((t) => ({
+      repo: t.repo, mode: 'local', branch: args.branch, base: t.defaultBranch,
+      worktree: t.worktree, commits: t.commits,
+    }));
   const pushed = [];
   try {
-    for (const t of active) {
+    for (const t of forgeActive) {
       pushBranch(deps.gitFn, t.worktree, t.repo, args.branch, { forceWithLease: args.forceWithLease });
       pushed.push(t.repo);
     }
 
-    for (const t of active) {
+    for (const t of forgeActive) {
       const forge = deps.forgeFactory({ ...(ws.workspace?.forge ?? {}), repo: `${t.owner}/${t.name}` });
       // Idempotency: a re-run must not open a second PR for a branch that
       // already has one open against the same base. Reuse it as-is —
@@ -244,13 +280,13 @@ async function createPrs(args, deps) {
       // default, and the one already open is the one reviewers watch.
       const existing = (await forge.prList({ state: 'open', head: args.branch, base: t.defaultBranch }))
         .find((p) => p.headRefName === args.branch && p.baseRefName === t.defaultBranch);
-      const title = issueTitle ?? firstCommitSubject(deps.gitFn, t.worktree, args.branch, t.defaultBranch);
+      const title = issueTitle ?? firstCommitSubject(deps.gitFn, t, args.branch);
       let body = readFileSync(args.bodyFiles.get(t.repo), 'utf8').replace(/\s*$/, '');
       if (issueRefs) body = `${body}\n\nCloses ${issueRefs.get(t.repo)}\n`;
       const pr = existing ?? await forge.prCreate({ title, body, head: args.branch, base: t.defaultBranch });
       prs.push({
-        repo: t.repo, owner: t.owner, name: t.name,
-        number: pr.number, id: pr.id, url: pr.url, isWorkspace: t.isWorkspace,
+        repo: t.repo, mode: 'forge', owner: t.owner, name: t.name,
+        number: pr.number, id: pr.id, url: pr.url, isWorkspace: t.isWorkspace, commits: t.commits,
       });
     }
   } catch (err) {
@@ -269,10 +305,40 @@ async function createPrs(args, deps) {
   return result;
 }
 
+// Merge one local-mode entry in its repo's source clone — repos/{repo} for
+// a project repo, the launcher itself for ".". The clone must be sitting
+// clean on its default branch: merging anywhere else would strand the
+// checkout or swallow uncommitted work. --ff-only because a task branch
+// that diverged from the local default needs a rebase first — deciding how
+// to combine is the user's, not this script's. A branch already contained
+// in the default branch counts as merged, which is what makes a re-run
+// after a partial failure safe.
+function mergeLocalEntry(gitFn, rootDir, entry) {
+  const repoDir = repoDirFor(rootDir, entry.repo);
+  const base = entry.base || defaultBranchFor(rootDir, entry.repo, gitFn);
+  const onBranch = gitOut(gitFn, repoDir, ['branch', '--show-current']);
+  if (onBranch !== base) {
+    throw new Error(`its source clone is on ${onBranch || 'a detached HEAD'}, not ${base} — check out ${base} and re-run --merge`);
+  }
+  if (String(gitCheck(gitFn, repoDir, ['status', '--porcelain']).stdout || '').trim() !== '') {
+    throw new Error('its source clone has uncommitted changes — commit or stash them and re-run --merge');
+  }
+  if (gitCheck(gitFn, repoDir, ['rev-parse', '--verify', '--quiet', `refs/heads/${entry.branch}`]).status !== 0) {
+    throw new Error(`branch ${entry.branch} not found in its source clone — nothing to merge`);
+  }
+  if (gitCheck(gitFn, repoDir, ['merge-base', '--is-ancestor', entry.branch, base]).status === 0) {
+    return { alreadyMerged: true };
+  }
+  const res = gitCheck(gitFn, repoDir, ['merge', '--ff-only', entry.branch]);
+  if (res.status !== 0) {
+    throw new Error(`${entry.branch} is not fast-forwardable onto ${base} — rebase the task branch onto ${base} and re-run --merge`);
+  }
+  return { alreadyMerged: false };
+}
+
 async function mergePrs(args, deps) {
   const rootDir = resolve(args.root);
   const ws = readWorkspace(rootDir);
-  assertForgeEnabled(ws);
 
   let parsed;
   try {
@@ -290,11 +356,25 @@ async function mergePrs(args, deps) {
   if (prs.length === 0) {
     throw new Error(`PRs file ${args.prs} lists no PRs — nothing to merge and nothing to close; --merge refuses to close an issue on an empty merge`);
   }
+  // Entries written before modes existed carry no `mode`; they are forge
+  // PRs, the only kind --create used to emit. A local entry's repo becomes
+  // a path under repos/, so the file cannot be allowed to name anything
+  // but "." or a plain single segment.
+  const modeOf = (p) => p?.mode ?? 'forge';
+  const REPO_NAME_RE = /^[A-Za-z0-9._-]+$/;
   for (const p of prs) {
-    if (!p || !p.owner || !p.name || !p.id) {
+    if (!p) throw new Error(`PRs file entry is missing owner/name/id: ${JSON.stringify(p)}`);
+    if (p.repo !== WORKSPACE_REPO
+      && (typeof p.repo !== 'string' || p.repo === '..' || !REPO_NAME_RE.test(p.repo))) {
+      throw new Error(`PRs file entry has an invalid repo name: ${JSON.stringify(p.repo)} — expected "." or a plain repo name`);
+    }
+    if (modeOf(p) === 'local') {
+      if (!p.branch) throw new Error(`PRs file entry is missing branch: ${JSON.stringify(p)}`);
+    } else if (!p.owner || !p.name || !p.id) {
       throw new Error(`PRs file entry is missing owner/name/id: ${JSON.stringify(p)}`);
     }
   }
+  if (prs.some((p) => modeOf(p) === 'forge')) assertForgeEnabled(ws);
   const forgeFor = (p) => deps.forgeFactory({ ...(ws.workspace?.forge ?? {}), repo: `${p.owner}/${p.name}` });
 
   // State first, so a re-run knows what an earlier run already finished.
@@ -304,57 +384,84 @@ async function mergePrs(args, deps) {
   // produces the honest error when something is genuinely wrong.
   const alreadyMerged = new Set();
   for (const p of prs) {
+    if (modeOf(p) !== 'forge') continue;
     try {
       const view = await forgeFor(p).prView({ id: p.id });
       if (view?.state === 'MERGED') alreadyMerged.add(p.id);
     } catch { /* state unknown — the merge attempt below decides */ }
   }
 
+  // Ordering rule: the project repos merge first — forge PRs and local
+  // branches alike, in file order — and the workspace repo last, only when
+  // every project merge succeeded: the workspace branch's promoted context
+  // describes the project merges and must never land ahead of them.
   const merged = [];
   const failures = [];
-  for (const p of prs.filter((x) => !x.isWorkspace)) {
-    if (alreadyMerged.has(p.id)) { merged.push(p); continue; }
-    try {
+  const workspaceEntry = prs.find((p) => p.repo === WORKSPACE_REPO) ?? null;
+  const mergeOne = async (p) => {
+    if (modeOf(p) === 'local') {
+      await mergeLocalEntry(deps.gitFn, rootDir, p);
+    } else if (!alreadyMerged.has(p.id)) {
       await forgeFor(p).prMerge({ id: p.id, strategy: 'squash', deleteBranch: true });
-      merged.push(p);
-    } catch (err) { failures.push(`${p.repo}: ${err.message}`); }
-  }
-  const workspacePr = prs.find((x) => x.isWorkspace) ?? null;
-  if (failures.length === 0 && workspacePr) {
-    if (alreadyMerged.has(workspacePr.id)) {
-      merged.push(workspacePr);
-    } else {
-      try {
-        await forgeFor(workspacePr).prMerge({ id: workspacePr.id, strategy: 'squash', deleteBranch: true });
-        merged.push(workspacePr);
-      } catch (err) { failures.push(`${workspacePr.repo}: ${err.message}`); }
     }
+    merged.push(p);
+  };
+  for (const p of prs.filter((x) => x !== workspaceEntry)) {
+    try { await mergeOne(p); } catch (err) { failures.push(`${p.repo}: ${err.message}`); }
+  }
+  if (failures.length === 0 && workspaceEntry) {
+    try { await mergeOne(workspaceEntry); } catch (err) { failures.push(`${workspaceEntry.repo}: ${err.message}`); }
   }
   if (failures.length > 0) {
-    const open = prs.filter((p) => !merged.includes(p)).map((p) => `${p.repo}: ${p.url}`);
+    const open = prs.filter((p) => !merged.includes(p)).map((p) => `${p.repo}: ${p.url ?? p.branch}`);
     throw new Error(
-      `merge stopped (${failures.join('; ')}). PRs still open: ${open.join(', ')}. The workspace PR is never merged ahead of the project PRs — fix the failure and re-run --merge.`,
+      `merge stopped (${failures.join('; ')}). Still open: ${open.join(', ')}. The workspace repo is never merged ahead of the project repos — fix the failure and re-run --merge.`,
     );
   }
 
-  // Every PR in the file is merged from here on. The launcher pull is a
+  // Every entry in the file is merged from here on. The launcher pull is a
   // convenience, not a gate: it happens only when the launcher sits on the
-  // workspace default branch, a failure is a reported flag rather than an
-  // error (the merges stand and the issue still closes), and the user is
-  // told to pull by hand before teardown.
-  const result = { merged: merged.map(({ repo, number, url }) => ({ repo, number, url })), closed: null };
-  const launcherBranch = gitOut(deps.gitFn, rootDir, ['branch', '--show-current']) || '(detached HEAD)';
-  if (launcherBranch !== defaultBranchFor(rootDir, WORKSPACE_REPO, deps.gitFn)) {
-    result.pullSkipped = `launcher on ${launcherBranch}`;
+  // workspace default branch and "." itself was not merged locally — that
+  // merge ran in the launcher, so it already has the work — a failure is a
+  // reported flag rather than an error (the merges stand and the issue
+  // still closes), and the user is told to pull by hand before teardown.
+  const result = {
+    merged: merged.map((p) => (modeOf(p) === 'local'
+      ? { repo: p.repo, mode: 'local', branch: p.branch, base: p.base }
+      : { repo: p.repo, mode: 'forge', number: p.number, url: p.url })),
+    closed: null,
+  };
+  if (merged.some((p) => p.repo === WORKSPACE_REPO && modeOf(p) === 'local')) {
+    result.pullSkipped = 'workspace merged locally';
   } else {
-    const pull = gitCheck(deps.gitFn, rootDir, ['pull', '--ff-only']);
-    if (pull.status !== 0) result.pullFailed = true;
+    const launcherBranch = gitOut(deps.gitFn, rootDir, ['branch', '--show-current']) || '(detached HEAD)';
+    if (launcherBranch !== defaultBranchFor(rootDir, WORKSPACE_REPO, deps.gitFn)) {
+      result.pullSkipped = `launcher on ${launcherBranch}`;
+    } else if (mergeModeFor(rootDir, WORKSPACE_REPO, { gitFn: deps.gitFn }) === 'local') {
+      // The workspace repo merges into the launcher itself — or was not part
+      // of this task at all; either way no forge merge happened that a pull
+      // could fetch.
+      result.pullSkipped = 'workspace repo is local';
+    } else if (gitCheck(deps.gitFn, rootDir, ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}']).status !== 0) {
+      result.pullSkipped = 'launcher has no upstream';
+    } else {
+      const pull = gitCheck(deps.gitFn, rootDir, ['pull', '--ff-only']);
+      if (pull.status !== 0) result.pullFailed = true;
+    }
   }
 
+  // The close needs both halves: a work item to close, and a tracker to
+  // close it on. A workspace without a tracker still merges everything —
+  // it just reports the skipped close instead of pretending one happened.
   if (args.workItem) {
-    const tracker = deps.trackerFactory(ws.workspace?.tracker);
-    await tracker.closeIssue(args.workItem, { comment: `Merged: ${merged.map((p) => p.url).join(' ')}` });
-    result.closed = args.workItem;
+    if (!ws.workspace?.tracker) {
+      result.closeSkipped = 'no tracker configured';
+    } else {
+      const tracker = deps.trackerFactory(ws.workspace.tracker);
+      const parts = merged.map((p) => (modeOf(p) === 'local' ? `${p.repo} ${p.branch}->${p.base}` : p.url));
+      await tracker.closeIssue(args.workItem, { comment: `Merged: ${parts.join(' ')}` });
+      result.closed = args.workItem;
+    }
   }
   return result;
 }
@@ -444,4 +551,5 @@ if (isMainModule(import.meta.url)) {
   });
 }
 
-export { run, parseArgs, parseForgeRemote };
+export { run, parseArgs };
+export { parseForgeRemote, mergeModeFor } from './merge-mode.mjs';

package/template/_claude/scripts/task-worktree.mjs

@@ -36,6 +36,7 @@ import { join, resolve, relative, sep, isAbsolute, basename, dirname } from 'nod
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { readRecord } from './chat-record.mjs';
+import { WORKSPACE_REPO, repoDirFor, mergeModeFor } from './merge-mode.mjs';
 
 function isMainModule(metaUrl) {
   if (!process.argv[1]) return false;
@@ -45,9 +46,6 @@ function isMainModule(metaUrl) {
 }
 
 const WORKTREES_DIR = join('.claude', 'worktrees');
-// The workspace repo (the launcher) is addressed as "." — the one repo
-// name that is not a directory under repos/.
-const WORKSPACE_REPO = '.';
 // Exclude patterns are git syntax: forward slashes on every platform.
 const EXCLUDE_LINE = '.claude/worktrees/';
 
@@ -65,12 +63,22 @@ function readConfig(root) {
 
 // The workspace repo has no workspace.json entry naming its default branch
 // — origin's HEAD is the authority, with "main" as the fallback a fresh
-// clone would get. Project repos keep their configured branch.
+// clone would get. A launcher with no origin never gets an origin/HEAD at
+// all, and no push will ever name its default branch either, so it keeps
+// the branch it sits on when that is main/master rather than being told it
+// is on the wrong branch. Project repos keep their configured branch.
 function defaultBranchFor(root, repo, gitFn = spawnSync) {
   if (isWorkspaceRepo(repo)) {
-    const res = gitFn('git', ['-C', resolve(root), 'symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], { encoding: 'utf8' });
-    const name = res && res.status === 0 ? String(res.stdout).trim().replace(/^origin\//, '') : '';
-    return name || 'main';
+    const rootDir = resolve(root);
+    const head = gitFn('git', ['-C', rootDir, 'symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], { encoding: 'utf8' });
+    const name = head && head.status === 0 ? String(head.stdout).trim().replace(/^origin\//, '') : '';
+    if (name) return name;
+    if (run(gitFn, rootDir, ['remote', 'get-url', 'origin']).status !== 0) {
+      const on = gitFn('git', ['-C', rootDir, 'branch', '--show-current'], { encoding: 'utf8' });
+      const current = on && on.status === 0 ? String(on.stdout).trim() : '';
+      if (current === 'main' || current === 'master') return current;
+    }
+    return 'main';
   }
   const branch = readConfig(root)?.repos?.[repo]?.branch;
   return typeof branch === 'string' && branch ? branch : 'main';
@@ -111,12 +119,6 @@ function taskWorktreePath(root, repo, branch) {
   return join(repoDirFor(resolve(root), repo), WORKTREES_DIR, slugForBranch(branch));
 }
 
-// "." is the workspace repo itself — the git repo at the root. Every other
-// name is a directory under repos/.
-function repoDirFor(rootDir, repo) {
-  return isWorkspaceRepo(repo) ? rootDir : join(rootDir, 'repos', repo);
-}
-
 // .native resolves Windows 8.3 short names; the plain fallback covers
 // filesystems where the native binding is unavailable.
 function realPath(p) {
@@ -233,10 +235,17 @@ function createTaskWorktree(root, { repo, branch, base = null, gitFn = spawnSync
   gitFn('git', ['-C', repoDir, 'fetch', 'origin'], { encoding: 'utf8', timeout: 10000 });
   run(gitFn, repoDir, ['worktree', 'prune']);
 
-  // The base is a starting point, not a freshness guarantee: it is
-  // origin's default branch as of the best-effort fetch above.
+  // The base is a starting point, not a freshness guarantee: origin's
+  // default branch as of the best-effort fetch above — unless the repo
+  // completes in local mode (gh:173: no origin, or merge: "local"), in
+  // which case the local default branch is the base. Local merges land
+  // there and never advance the origin ref, so preferring origin's would
+  // hand every task after the first local merge a stale, unmergeable base.
   const defaultBranch = defaultBranchFor(rootDir, repo, gitFn);
   const resolvedBase = base
+    || (mergeModeFor(rootDir, repo, { gitFn }) === 'local'
+      ? defaultBranch
+      : null)
     || (refExists(gitFn, repoDir, `refs/remotes/origin/${defaultBranch}`)
       ? `origin/${defaultBranch}`
       : defaultBranch);
@@ -520,6 +529,7 @@ if (isMainModule(import.meta.url)) {
 
 export {
   slugForBranch, taskWorktreePath, createTaskWorktree, removeTaskWorktree,
-  detectWorkModel, parseArgs, defaultBranchFor, WORKSPACE_REPO,
+  detectWorkModel, parseArgs, defaultBranchFor,
   WORKTREES_DIR, EXCLUDE_LINE,
 };
+export { WORKSPACE_REPO, repoDirFor } from './merge-mode.mjs';