@stylusnexus/work-plan 2026.6.10 → 2026.6.11

package/skills/work-plan/lib/git_state.py

@@ -4,6 +4,39 @@ from datetime import date, datetime, timedelta
 from pathlib import Path
 from typing import Optional
 
+# Bound every git subprocess so a hung repo, a stuck lock, or a slow network
+# filesystem can't stall the CLI (or the VS Code extension that spawns it)
+# indefinitely (#196). 20s is generous for local git operations.
+GIT_TIMEOUT = 20
+
+
+def is_safe_ref(name: str) -> bool:
+    """True if `name` is safe to pass to git as a positional revision.
+
+    Rejects empty strings and anything beginning with '-'. A branch/rev that
+    starts with a dash is read by git as an OPTION, not a value — e.g. a branch
+    named `--output=/path` turns `git log <branch> …` into an arbitrary-file
+    write (#192). git refnames cannot legitimately start with '-', so this
+    rejects nothing valid. Callers must gate every positional rev on this.
+    """
+    return bool(name) and not name.startswith("-")
+
+
+def _git(repo_path, *args, timeout: int = GIT_TIMEOUT):
+    """Run `git -C <repo_path> <args>` with a bounded timeout.
+
+    Returns the CompletedProcess, or None on timeout / spawn failure — callers
+    treat None as "no data", preserving the never-raise contract these helpers
+    have always had.
+    """
+    try:
+        return subprocess.run(
+            ["git", "-C", str(repo_path), *args],
+            capture_output=True, text=True, timeout=timeout,
+        )
+    except (subprocess.TimeoutExpired, OSError):
+        return None
+
 
 def gap_seconds_to_label(seconds: int) -> str:
     """'Nm ago' / 'Nh ago' / 'Nd ago'."""
@@ -26,11 +59,8 @@ def parse_iso_timestamp(s: str) -> datetime:
 def current_branch(repo_path: Path) -> Optional[str]:
     if not repo_path or not Path(repo_path).exists():
         return None
-    proc = subprocess.run(
-        ["git", "-C", str(repo_path), "branch", "--show-current"],
-        capture_output=True, text=True,
-    )
-    if proc.returncode != 0:
+    proc = _git(repo_path, "branch", "--show-current")
+    if proc is None or proc.returncode != 0:
         return None
     return proc.stdout.strip() or None
 
@@ -38,21 +68,15 @@ def current_branch(repo_path: Path) -> Optional[str]:
 def has_uncommitted(repo_path: Path) -> bool:
     if not repo_path or not Path(repo_path).exists():
         return False
-    proc = subprocess.run(
-        ["git", "-C", str(repo_path), "status", "--short"],
-        capture_output=True, text=True,
-    )
-    return proc.returncode == 0 and bool(proc.stdout.strip())
+    proc = _git(repo_path, "status", "--short")
+    return proc is not None and proc.returncode == 0 and bool(proc.stdout.strip())
 
 
 def uncommitted_file_count(repo_path: Path) -> int:
     if not repo_path or not Path(repo_path).exists():
         return 0
-    proc = subprocess.run(
-        ["git", "-C", str(repo_path), "status", "--short"],
-        capture_output=True, text=True,
-    )
-    if proc.returncode != 0:
+    proc = _git(repo_path, "status", "--short")
+    if proc is None or proc.returncode != 0:
         return 0
     return len([l for l in proc.stdout.splitlines() if l.strip()])
 
@@ -60,11 +84,12 @@ def uncommitted_file_count(repo_path: Path) -> int:
 def commits_ahead(branch_name: str, base: str, repo_path: Path) -> int:
     if not repo_path or not Path(repo_path).exists():
         return 0
-    proc = subprocess.run(
-        ["git", "-C", str(repo_path), "rev-list", "--count", f"{base}..{branch_name}"],
-        capture_output=True, text=True,
-    )
-    if proc.returncode != 0:
+    # Both refs are interpolated into a single `base..branch` positional, so a
+    # dash-led value would be read as a git option — reject before use (#192).
+    if not is_safe_ref(branch_name) or not is_safe_ref(base):
+        return 0
+    proc = _git(repo_path, "rev-list", "--count", f"{base}..{branch_name}")
+    if proc is None or proc.returncode != 0:
         return 0
     try:
         return int(proc.stdout.strip())
@@ -75,11 +100,10 @@ def commits_ahead(branch_name: str, base: str, repo_path: Path) -> int:
 def branch_exists(branch_name: str, repo_path: Path) -> bool:
     if not repo_path or not Path(repo_path).exists():
         return False
-    proc = subprocess.run(
-        ["git", "-C", str(repo_path), "rev-parse", "--verify", branch_name],
-        capture_output=True, text=True,
-    )
-    return proc.returncode == 0
+    if not is_safe_ref(branch_name):
+        return False
+    proc = _git(repo_path, "rev-parse", "--verify", branch_name)
+    return proc is not None and proc.returncode == 0
 
 
 def _has_recent_commits(branch_name: str, repo_path: Path, hours: int = 24) -> bool:
@@ -88,12 +112,8 @@ def _has_recent_commits(branch_name: str, repo_path: Path, hours: int = 24) -> b
     if not branch_exists(branch_name, repo_path):
         return False
     since = (datetime.now() - timedelta(hours=hours)).strftime("%Y-%m-%dT%H:%M:%S")
-    proc = subprocess.run(
-        ["git", "-C", str(repo_path), "log", branch_name,
-         f"--since={since}", "--pretty=format:%H"],
-        capture_output=True, text=True,
-    )
-    return proc.returncode == 0 and bool(proc.stdout.strip())
+    proc = _git(repo_path, "log", branch_name, f"--since={since}", "--pretty=format:%H")
+    return proc is not None and proc.returncode == 0 and bool(proc.stdout.strip())
 
 
 def branch_in_progress(branch_name: str, repo_path: Path) -> bool:
@@ -117,11 +137,8 @@ def last_commit_date(branch_name: str, repo_path: Path) -> Optional[datetime]:
         return None
     if not branch_exists(branch_name, repo_path):
         return None
-    proc = subprocess.run(
-        ["git", "-C", str(repo_path), "log", "-1", branch_name, "--pretty=format:%cI"],
-        capture_output=True, text=True,
-    )
-    if proc.returncode != 0 or not proc.stdout.strip():
+    proc = _git(repo_path, "log", "-1", branch_name, "--pretty=format:%cI")
+    if proc is None or proc.returncode != 0 or not proc.stdout.strip():
         return None
     try:
         s = proc.stdout.strip().split("+")[0].split("Z")[0]
@@ -134,11 +151,8 @@ def path_last_commit_date(rel_path: str, repo_path: Path) -> Optional[datetime]:
     """Timestamp of the most recent commit touching `rel_path` (naive datetime)."""
     if not repo_path or not Path(repo_path).exists():
         return None
-    proc = subprocess.run(
-        ["git", "-C", str(repo_path), "log", "-1", "--pretty=format:%cI", "--", rel_path],
-        capture_output=True, text=True,
-    )
-    if proc.returncode != 0 or not proc.stdout.strip():
+    proc = _git(repo_path, "log", "-1", "--pretty=format:%cI", "--", rel_path)
+    if proc is None or proc.returncode != 0 or not proc.stdout.strip():
         return None
     try:
         s = proc.stdout.strip().split("+")[0].split("Z")[0]
@@ -159,12 +173,10 @@ def path_committed_since(rel_path: str, since: date, repo_path: Path) -> bool:
     if not repo_path or not Path(repo_path).exists():
         return False
     window_start = since - timedelta(days=1)
-    proc = subprocess.run(
-        ["git", "-C", str(repo_path), "log",
-         f"--since={window_start.isoformat()}", "--pretty=format:%H", "--", rel_path],
-        capture_output=True, text=True,
-    )
-    return proc.returncode == 0 and bool(proc.stdout.strip())
+    proc = _git(repo_path, "log",
+                f"--since={window_start.isoformat()}", "--pretty=format:%H",
+                "--", rel_path)
+    return proc is not None and proc.returncode == 0 and bool(proc.stdout.strip())
 
 
 def git_mv(src_rel: str, dst_rel: str, repo_path: Path) -> bool:
@@ -173,8 +185,5 @@ def git_mv(src_rel: str, dst_rel: str, repo_path: Path) -> bool:
     if not repo_path or not Path(repo_path).exists():
         return False
     (Path(repo_path) / dst_rel).parent.mkdir(parents=True, exist_ok=True)
-    proc = subprocess.run(
-        ["git", "-C", str(repo_path), "mv", src_rel, dst_rel],
-        capture_output=True, text=True,
-    )
-    return proc.returncode == 0
+    proc = _git(repo_path, "mv", src_rel, dst_rel)
+    return proc is not None and proc.returncode == 0

package/skills/work-plan/lib/github_state.py

@@ -15,16 +15,30 @@ _GH_ISSUE_FIELDS = "number,state,labels,title,milestone,url,closedAt,body,update
 _REPO_RE = re.compile(r"^[\w.-]+/[\w.-]+$")
 GQL_CHUNK = 100  # issues per GraphQL query; GitHub GraphQL complexity budget ~5000 pts/query, 100 issueOrPullRequest nodes is well within it
 
+# Bound every `gh` subprocess so a network stall can't hang the CLI (or the
+# VS Code extension that spawns it) indefinitely (#196). The concurrent fetch
+# paths compound an unbounded stall across a thread pool, so this matters.
+GH_TIMEOUT = 30
+
+
+def _valid_repo(repo: str) -> bool:
+    """True when `repo` looks like `owner/name`. Callers that pass it to `gh`
+    should gate on this so a malformed config slug fails fast rather than
+    reaching the network (and never lands in argv as something flag-like)."""
+    return bool(repo) and _REPO_RE.match(repo) is not None
+
 
 def fetch_issue(repo: str, number: int) -> Optional[dict]:
     """Fetch a single issue via gh. Returns parsed dict on success, None on failure.
-    Never raises — a missing `gh` binary or any subprocess error yields None."""
+    Never raises — a missing `gh` binary, a timeout, or a bad repo yields None."""
+    if not _valid_repo(repo):
+        return None
     try:
         proc = subprocess.run(
             ["gh", "issue", "view", str(number),
              "--repo", repo,
              "--json", _GH_ISSUE_FIELDS],
-            capture_output=True, text=True,
+            capture_output=True, text=True, timeout=GH_TIMEOUT,
         )
     except Exception:
         return None
@@ -158,7 +172,7 @@ def fetch_repo_issues_graphql(repo: str, numbers, chunk: int = GQL_CHUNK,
         try:
             proc = subprocess.run(
                 ["gh", "api", "graphql", "-f", "query=" + _gql_query(owner, name, batch, fields=fields)],
-                capture_output=True, text=True,
+                capture_output=True, text=True, timeout=GH_TIMEOUT,
             )
         except Exception:
             return {}
@@ -224,7 +238,7 @@ def fetch_open_issues(repo: str, limit: int = 1000) -> list[dict]:
              "--state", "open",
              "--json", "number,title,state,assignees,milestone",
              "--limit", str(limit)],
-            capture_output=True, text=True,
+            capture_output=True, text=True, timeout=GH_TIMEOUT,
         )
     except Exception:
         return []
@@ -238,6 +252,8 @@ def fetch_open_issues(repo: str, limit: int = 1000) -> list[dict]:
 
 def fetch_recent_issues(repo: str, since_iso: str, extra_labels: list[str] = None) -> list[dict]:
     """Fetch issues created since `since_iso` (date YYYY-MM-DD)."""
+    if not _valid_repo(repo):
+        return []
     search = f"created:>={since_iso}"
     cmd = ["gh", "issue", "list", "--repo", repo,
            "--state", "all",
@@ -247,7 +263,10 @@ def fetch_recent_issues(repo: str, since_iso: str, extra_labels: list[str] = Non
     if extra_labels:
         for lab in extra_labels:
             cmd.extend(["--label", lab])
-    proc = subprocess.run(cmd, capture_output=True, text=True)
+    try:
+        proc = subprocess.run(cmd, capture_output=True, text=True, timeout=GH_TIMEOUT)
+    except Exception:
+        return []
     if proc.returncode != 0:
         return []
     return json.loads(proc.stdout) if proc.stdout.strip() else []
@@ -263,10 +282,19 @@ def repo_visibility(repo: str) -> Optional[str]:
         return None
     if repo in _VIS_CACHE:
         return _VIS_CACHE[repo]
-    proc = subprocess.run(
-        ["gh", "repo", "view", repo, "--json", "visibility"],
-        capture_output=True, text=True,
-    )
+    if not _valid_repo(repo):
+        _VIS_CACHE[repo] = None
+        return None
+    try:
+        proc = subprocess.run(
+            ["gh", "repo", "view", repo, "--json", "visibility"],
+            capture_output=True, text=True, timeout=GH_TIMEOUT,
+        )
+    except Exception:
+        # Timeout / spawn failure → unknown visibility. needs_confirm() fails
+        # CLOSED on None (it still prompts), so this never weakens the gate.
+        _VIS_CACHE[repo] = None
+        return None
     vis = None
     if proc.returncode == 0 and proc.stdout.strip():
         try:
@@ -328,10 +356,15 @@ def state_to_status_label(state: str) -> str:
 def create_issue(repo: str, title: str, body: str) -> Optional[str]:
     """Open a GitHub issue via `gh issue create`. Returns the issue URL, or None
     on failure. Reuses the user's `gh` auth; never touches tokens."""
-    proc = subprocess.run(
-        ["gh", "issue", "create", "--repo", repo, "--title", title, "--body", body],
-        capture_output=True, text=True,
-    )
+    if not _valid_repo(repo):
+        return None
+    try:
+        proc = subprocess.run(
+            ["gh", "issue", "create", "--repo", repo, "--title", title, "--body", body],
+            capture_output=True, text=True, timeout=GH_TIMEOUT,
+        )
+    except Exception:
+        return None
     if proc.returncode != 0:
         return None
     return proc.stdout.strip() or None

package/skills/work-plan/lib/notes_vcs.py

@@ -0,0 +1,276 @@
+"""Opt-in local version control for the private notes_root tier (#103).
+
+The shared tier (`<repo>/.work-plan/`) is version-controlled by the repo it
+lives in. The private tier (`notes_root`, e.g. `Project Notes/`) is not — so a
+track edit (slot/group/handoff/close/set) has no history or undo. This module
+adds an opt-in, *personal, never-pushed* git repo at notes_root: every
+track-mutating command becomes an undoable commit + diff.
+
+Every helper here NEVER raises — git absence, a stuck lock, a slow filesystem,
+or a non-repo all resolve to "do nothing". A VCS failure must never change a
+command's exit code (the dispatcher relies on this).
+
+Safety rule: we only ever operate when notes_root is the git TOPLEVEL. If
+notes_root sits inside someone else's repo (the workspace, a clone), we refuse
+to `git add -A` there — that would sweep unrelated files into a foreign repo.
+`notes-vcs init` makes notes_root its own root, satisfying this.
+"""
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+# Bound every git subprocess so a stuck lock or slow FS can't stall the CLI
+# (mirrors git_state.GIT_TIMEOUT; kept local to avoid a cross-module coupling).
+GIT_TIMEOUT = 20
+
+_GITIGNORE = ".DS_Store\nThumbs.db\n"
+_INIT_COMMIT_MSG = "work-plan: initialize notes_root local history"
+
+# Local git-config marker stamped on the repos work-plan creates for local
+# history. We only ever auto-commit a repo carrying this marker, so we never
+# adopt (and commit into) an arbitrary pre-existing repo the user pointed
+# notes_root at.
+_OWNED_KEY = "workplan.localhistory"
+
+
+def _git(notes_root, *args, timeout: int = GIT_TIMEOUT):
+    """Run `git -C <notes_root> <args>`; return CompletedProcess or None.
+
+    None means git is missing, timed out, or the spawn failed — callers treat
+    it as "no data / could not act", preserving the never-raise contract.
+    """
+    try:
+        return subprocess.run(
+            ["git", "-C", str(notes_root), *args],
+            capture_output=True, text=True, timeout=timeout,
+        )
+    except (subprocess.TimeoutExpired, OSError):
+        return None
+
+
+def is_git_root(notes_root: Path) -> bool:
+    """True only if notes_root is itself the toplevel of a git work tree.
+
+    A bare `.git` existence check would also pass for a subdirectory of a larger
+    repo, where `git add -A` would stage unrelated files. We compare the
+    resolved toplevel to the resolved notes_root so auto-commit only ever fires
+    on a repo we own.
+    """
+    if not notes_root:
+        return False
+    root = Path(notes_root).expanduser()
+    if not root.is_dir():
+        return False
+    proc = _git(root, "rev-parse", "--show-toplevel")
+    if proc is None or proc.returncode != 0:
+        return False
+    top = proc.stdout.strip()
+    if not top:
+        return False
+    try:
+        return Path(top).resolve() == root.resolve()
+    except OSError:
+        return False
+
+
+def is_under_git(notes_root: Path) -> bool:
+    """True if notes_root is inside ANY git work tree (root or subdir).
+
+    Used by status/nudge messaging to distinguish "not a repo at all" from
+    "inside a repo but not its root" (the latter we deliberately won't touch).
+    """
+    if not notes_root:
+        return False
+    root = Path(notes_root).expanduser()
+    if not root.is_dir():
+        return False
+    proc = _git(root, "rev-parse", "--is-inside-work-tree")
+    return proc is not None and proc.returncode == 0 and proc.stdout.strip() == "true"
+
+
+def has_changes(notes_root: Path) -> bool:
+    """True if the notes_root work tree has staged or unstaged changes."""
+    proc = _git(notes_root, "status", "--short")
+    return proc is not None and proc.returncode == 0 and bool(proc.stdout.strip())
+
+
+def has_remotes(notes_root: Path) -> bool:
+    """True if the repo has ANY configured remote.
+
+    A personal local-history repo must have none — otherwise private notes
+    could be pushed off the machine. Used to refuse enabling/committing history
+    on a remote-backed repo.
+    """
+    proc = _git(notes_root, "remote")
+    return proc is not None and proc.returncode == 0 and bool(proc.stdout.strip())
+
+
+def is_owned(notes_root: Path) -> bool:
+    """True only if work-plan created this repo for local history.
+
+    `init_repo` stamps a local git-config marker; auto-commit requires it, so we
+    never commit into a repo we don't control (e.g. an existing clone the user
+    pointed notes_root at).
+    """
+    proc = _git(notes_root, "config", "--local", "--get", _OWNED_KEY)
+    return proc is not None and proc.returncode == 0 and proc.stdout.strip() == "true"
+
+
+def mark_owned(notes_root: Path) -> bool:
+    """Stamp the ownership marker into the repo's local config. Returns success."""
+    proc = _git(notes_root, "config", "--local", _OWNED_KEY, "true")
+    return proc is not None and proc.returncode == 0
+
+
+def head_parent_sha(notes_root: Path) -> Optional[str]:
+    """Short sha of HEAD's first parent, or None (root commit / no commits / not
+    a repo). The viewer compares this to the previously-seen HEAD to confirm a
+    post-write commit sits directly on top before offering Undo (#224 safety)."""
+    proc = _git(notes_root, "rev-parse", "--short", "--verify", "HEAD^")
+    if proc is None or proc.returncode != 0 or not proc.stdout.strip():
+        return None
+    return proc.stdout.strip()
+
+
+def dirty_paths(notes_root: Path) -> set:
+    """Set of work-tree paths with staged/unstaged changes (raw, quotepath off).
+
+    Empty set on any failure. Renames collapse to the destination path. Used by
+    the dispatcher to commit ONLY what a command changed, leaving pre-existing
+    dirty files untouched.
+    """
+    proc = _git(notes_root, "-c", "core.quotepath=false", "status", "--porcelain")
+    if proc is None or proc.returncode != 0:
+        return set()
+    paths = set()
+    for line in proc.stdout.splitlines():
+        if len(line) < 4:
+            continue
+        path = line[3:]
+        if " -> " in path:  # rename / copy → the destination path
+            path = path.split(" -> ", 1)[1]
+        if path:
+            paths.add(path)
+    return paths
+
+
+def last_commit_summary(notes_root: Path) -> Optional[str]:
+    """'<short-sha> <subject>' of HEAD, or None (no commits / not a repo)."""
+    proc = _git(notes_root, "log", "-1", "--pretty=format:%h %s")
+    if proc is None or proc.returncode != 0 or not proc.stdout.strip():
+        return None
+    return proc.stdout.strip()
+
+
+def last_commit_sha(notes_root: Path) -> Optional[str]:
+    """Short sha of HEAD, or None (no commits / not a repo). The undo handle the
+    VS Code viewer diffs across a write to decide whether to offer Undo (#224)."""
+    proc = _git(notes_root, "log", "-1", "--pretty=format:%h")
+    if proc is None or proc.returncode != 0 or not proc.stdout.strip():
+        return None
+    return proc.stdout.strip()
+
+
+def revert(notes_root: Path, sha: Optional[str] = None) -> Optional[str]:
+    """Revert `sha` (default HEAD) in notes_root; return the new commit's sha.
+
+    Keeps git inside the engine so callers (the CLI `undo` verb, the viewer's
+    Undo button) never shell out to git themselves. No-op (None) when notes_root
+    isn't a git root we OWN with no remote (same boundary as auto_commit — we
+    must never rewrite an unrelated project clone's history), when there's no
+    commit to revert, or when `sha` is unsafe (empty / dash-led — git would read
+    a dash-led value as an option). Never raises. Uses --no-edit (non-interactive).
+    """
+    root = Path(notes_root).expanduser()
+    if not is_git_root(root) or not is_owned(root) or has_remotes(root):
+        return None
+    target = sha if sha is not None else "HEAD"
+    # A dash-led ref would be parsed by git as an option, not a revision.
+    if not target or target.startswith("-"):
+        return None
+    proc = _git(root, "revert", "--no-edit", target)
+    if proc is None or proc.returncode != 0:
+        return None
+    return last_commit_sha(root)
+
+
+def init_repo(notes_root: Path) -> bool:
+    """git-init notes_root as a personal repo and make an initial commit.
+
+    Writes a small `.gitignore` (OS cruft only), stages everything, and commits
+    existing tracks so there's a baseline to diff against. Deliberately adds NO
+    remote — the private tier is never pushed. Returns True on a clean init +
+    initial commit, False on any failure (never raises).
+
+    Idempotent-ish: re-running on a repo WE own re-commits only if there's
+    something new. Refuses (returns False) to adopt a repo we did not create or
+    one that has a remote — private notes must never be pushable, and we won't
+    sweep an unrelated existing repo's files into history.
+    """
+    root = Path(notes_root).expanduser()
+    if not root.is_dir():
+        return False
+    if is_git_root(root):
+        # An existing repo: only proceed if it's one we own AND has no remote.
+        if has_remotes(root) or not is_owned(root):
+            return False
+    else:
+        if _git(root, "init") is None:
+            return False
+        # Stamp ownership immediately, before any commit, so this repo can never
+        # later be mistaken for a foreign one (and a remote added after init is
+        # still caught by auto_commit's per-commit no-remote check).
+        if not mark_owned(root):
+            return False
+    gitignore = root / ".gitignore"
+    if not gitignore.exists():
+        try:
+            gitignore.write_text(_GITIGNORE, encoding="utf-8")
+        except OSError:
+            return False
+    if _git(root, "add", "-A") is None:
+        return False
+    # Nothing to commit (e.g. re-init of an unchanged repo) is success, not error.
+    if not has_changes(root) and last_commit_summary(root) is not None:
+        return True
+    proc = _git(root, "commit", "-m", _INIT_COMMIT_MSG)
+    return proc is not None and proc.returncode == 0
+
+
+def auto_commit(notes_root: Path, message: str,
+                paths: Optional[list] = None) -> Optional[str]:
+    """Commit notes_root changes with `message`; return the new short SHA.
+
+    Safety gates (all must hold, else no-op None):
+      - notes_root is the git toplevel,
+      - it carries the ownership marker (work-plan created it), and
+      - it has NO remote (a personal, never-pushed history).
+
+    When `paths` is given, stages ONLY those paths so unrelated pre-existing
+    dirty files stay out of the commit; otherwise stages everything. Commits
+    only if something is actually staged. Never raises — a git failure here must
+    not change the calling command's exit code.
+    """
+    root = Path(notes_root).expanduser()
+    if not is_git_root(root) or not is_owned(root) or has_remotes(root):
+        return None
+    if paths is None:
+        if _git(root, "add", "-A") is None:
+            return None
+    else:
+        if not paths:
+            return None
+        if _git(root, "add", "--", *paths) is None:
+            return None
+    # Commit only what's staged — scoped `add` above keeps unrelated dirty files
+    # unstaged, so they're preserved rather than folded into this commit.
+    staged = _git(root, "diff", "--cached", "--quiet")
+    if staged is None or staged.returncode == 0:
+        return None
+    proc = _git(root, "commit", "-m", message)
+    if proc is None or proc.returncode != 0:
+        return None
+    head = _git(root, "rev-parse", "--short", "HEAD")
+    if head is None or head.returncode != 0:
+        return None
+    return head.stdout.strip() or None

package/skills/work-plan/lib/prompts.py

@@ -80,14 +80,25 @@ def parse_flags(args: list[str], known: set[str]) -> tuple[dict, list[str]]:
     For `--key=value` flags, key.split("=", 1)[0] is matched against `known`.
 
     Returns: (flags_dict, positional_list).
-      - flags_dict: {"--all": True, "--repo": "critforge", ...} for flags found.
+      - flags_dict: {"--all": True, "--repo": "myproject", ...} for flags found.
       - positional_list: args that aren't flags.
 
     Unknown flags are passed through as positional args (caller decides what to do).
     """
     flags = {}
     positional = []
+    end_of_opts = False
     for arg in args:
+        # A bare `--` ends option parsing: everything after it is positional,
+        # even if it begins with `--`. Lets callers (e.g. the VS Code extension)
+        # pass a GitHub-derived value like a `--repo`-named track as a plain
+        # positional instead of having it misparsed as a flag (#194).
+        if end_of_opts:
+            positional.append(arg)
+            continue
+        if arg == "--":
+            end_of_opts = True
+            continue
         if not arg.startswith("--"):
             positional.append(arg)
             continue