Release 0.7.0

.archon/commands/defaults/archon-create-pr.md

@@ -19,12 +19,16 @@ Extract the issue number from the current branch name or context (e.g., `fix/iss
 ```bash
 BRANCH=$(git branch --show-current)
 ISSUE_NUM=$(echo "$BRANCH" | grep -oE '[0-9]+' | tail -1)
+# Pin all gh pr commands to the origin remote — in a fork clone, gh otherwise
+# targets the upstream parent repo. Re-run this line in every new shell.
+ORIGIN_REPO=$(git remote get-url origin | sed -E 's#^.*[:/]([^/]+/[^/]+)$#\1#; s#\.git$##')
 ```
 
 If an issue number was found, search for open PRs that already reference it:
 
 ```bash
 gh pr list \
+  --repo "$ORIGIN_REPO" \
   --search "Fixes #${ISSUE_NUM} OR Closes #${ISSUE_NUM}" \
   --state open \
   --json number,url,headRefName
@@ -156,7 +160,11 @@ cat > $ARTIFACTS_DIR/pr-body.md <<'EOF'
 [body from above]
 EOF
 
+# Fork-safe target: without --repo, gh opens the PR against the upstream parent
+ORIGIN_REPO=$(git remote get-url origin | sed -E 's#^.*[:/]([^/]+/[^/]+)$#\1#; s#\.git$##')
+
 gh pr create \
+  --repo "$ORIGIN_REPO" \
   --title "[title]" \
   --body-file $ARTIFACTS_DIR/pr-body.md \
   --base $BASE_BRANCH
@@ -165,17 +173,18 @@ gh pr create \
 Or if the content is simple:
 
 ```bash
-gh pr create --fill --base $BASE_BRANCH
+gh pr create --repo "$ORIGIN_REPO" --fill --base $BASE_BRANCH
 ```
 
 After creating the PR, capture its identifiers for downstream steps. Only write artifacts if PR creation succeeded — never persist stale data from a pre-existing PR:
 
 ```bash
 # After creating the PR, capture and persist the PR number for downstream steps
 # IMPORTANT: Only write artifacts after confirmed successful PR creation
-if gh pr view --json number,url -q '.number,.url' > /dev/null 2>&1; then
-  PR_NUMBER=$(gh pr view --json number -q '.number')
-  PR_URL=$(gh pr view --json url -q '.url')
+ORIGIN_REPO=$(git remote get-url origin | sed -E 's#^.*[:/]([^/]+/[^/]+)$#\1#; s#\.git$##')
+if gh pr view --repo "$ORIGIN_REPO" --json number,url -q '.number,.url' > /dev/null 2>&1; then
+  PR_NUMBER=$(gh pr view --repo "$ORIGIN_REPO" --json number -q '.number')
+  PR_URL=$(gh pr view --repo "$ORIGIN_REPO" --json url -q '.url')
   echo "$PR_NUMBER" > "$ARTIFACTS_DIR/.pr-number"
   echo "$PR_URL" > "$ARTIFACTS_DIR/.pr-url"
 else
@@ -219,7 +228,8 @@ Nothing to create a PR for.
 ### Branch Already Has PR
 
 ```bash
-gh pr view --web
+ORIGIN_REPO=$(git remote get-url origin | sed -E 's#^.*[:/]([^/]+/[^/]+)$#\1#; s#\.git$##')
+gh pr view --repo "$ORIGIN_REPO" --web
 ```
 
 Opens the existing PR instead of creating a duplicate.

.archon/commands/defaults/archon-finalize-pr.md

@@ -47,7 +47,10 @@ Extract:
 ### 1.3 Check for Existing PR
 
 ```bash
-gh pr list --head $(git branch --show-current) --json number,url,state
+# Pin all gh pr commands to the origin remote — in a fork clone, gh otherwise
+# targets the upstream parent repo. Re-run this line in every new shell.
+ORIGIN_REPO=$(git remote get-url origin | sed -E 's#^.*[:/]([^/]+/[^/]+)$#\1#; s#\.git$##')
+gh pr list --repo "$ORIGIN_REPO" --head $(git branch --show-current) --json number,url,state
 ```
 
 **If PR already exists**: Will update it instead of creating new one.
@@ -190,7 +193,11 @@ cat > $ARTIFACTS_DIR/pr-body.md <<'EOF'
 {prepared-body}
 EOF
 
+# Fork-safe target: without --repo, gh opens the PR against the upstream parent
+ORIGIN_REPO=$(git remote get-url origin | sed -E 's#^.*[:/]([^/]+/[^/]+)$#\1#; s#\.git$##')
+
 gh pr create \
+  --repo "$ORIGIN_REPO" \
   --title "{plan-title}" \
   --body-file $ARTIFACTS_DIR/pr-body.md \
   --base $BASE_BRANCH
@@ -199,30 +206,34 @@ gh pr create \
 **If PR already exists**, update it:
 
 ```bash
-gh pr edit {pr-number} --body-file $ARTIFACTS_DIR/pr-body.md
+ORIGIN_REPO=$(git remote get-url origin | sed -E 's#^.*[:/]([^/]+/[^/]+)$#\1#; s#\.git$##')
+gh pr edit {pr-number} --repo "$ORIGIN_REPO" --body-file $ARTIFACTS_DIR/pr-body.md
 ```
 
 ### 3.3 Ensure Ready for Review
 
 If PR was created as draft, mark ready:
 
 ```bash
-gh pr ready {pr-number} 2>/dev/null || true
+ORIGIN_REPO=$(git remote get-url origin | sed -E 's#^.*[:/]([^/]+/[^/]+)$#\1#; s#\.git$##')
+gh pr ready {pr-number} --repo "$ORIGIN_REPO" 2>/dev/null || true
 ```
 
 ### 3.4 Capture PR Info
 
 ```bash
-gh pr view --json number,url,headRefName,baseRefName
+ORIGIN_REPO=$(git remote get-url origin | sed -E 's#^.*[:/]([^/]+/[^/]+)$#\1#; s#\.git$##')
+gh pr view --repo "$ORIGIN_REPO" --json number,url,headRefName,baseRefName
 ```
 
 ### 3.5 Write PR Number Registry
 
 Write PR number for downstream review steps:
 
 ```bash
-PR_NUMBER=$(gh pr view --json number -q '.number')
-PR_URL=$(gh pr view --json url -q '.url')
+ORIGIN_REPO=$(git remote get-url origin | sed -E 's#^.*[:/]([^/]+/[^/]+)$#\1#; s#\.git$##')
+PR_NUMBER=$(gh pr view --repo "$ORIGIN_REPO" --json number -q '.number')
+PR_URL=$(gh pr view --repo "$ORIGIN_REPO" --json url -q '.url')
 echo "$PR_NUMBER" > $ARTIFACTS_DIR/.pr-number
 echo "$PR_URL" > $ARTIFACTS_DIR/.pr-url
 ```
@@ -387,8 +398,9 @@ Check:
 ```
 ❌ PR not found: #{number}
 
-The draft PR may have been closed or deleted. Create a new one:
-`gh pr create --title "..." --body "..."`
+The draft PR may have been closed or deleted. Create a new one
+(re-run the `ORIGIN_REPO=...` resolve line first — it does not persist across shells):
+`gh pr create --repo "$ORIGIN_REPO" --title "..." --body "..."`
 ```
 
 ### Template Parsing

.archon/commands/defaults/archon-fix-issue.md

@@ -9,6 +9,50 @@ argument-hint: <issue-number|artifact-path>
 
 ---
 
+## READ FIRST: you are almost certainly in a run worktree
+
+When this command runs inside an Archon workflow, the isolation system has **already**
+created a git worktree on the correct branch. In that case:
+
+- **Use the current branch as-is.** Do not switch branches, do not create one, do not
+  fetch-and-reset. The branch you are on is the branch this work belongs to.
+- **A dirty working tree is expected and is NOT a reason to stop.** Archon copies the
+  operator's `.archon/` directory — workflows, commands, scripts — into every run
+  worktree, deliberately, so a workflow can be iterated on before it is committed.
+  Those files are present *before* you start and are not your changes.
+- **Modifications under `.archon/` are never yours to commit, stash, or remove.**
+  Leave them exactly as they are and commit only the files your implementation touched.
+  Before every commit, confirm with `git diff --cached --name-only` that nothing under
+  `.archon/` is staged.
+- **Dirty paths outside `.archon/` are also not a reason to stop, and also not yours.**
+  They are either your own work from an earlier attempt at this run (resume reuses the
+  worktree) or something the operator left behind. Either way: leave them alone, do not
+  fold them into your commit, and stage your own files by name rather than with
+  `git add -A`.
+
+The clean-working-tree requirement in the decision tree below applies **only** to the
+`ON $BASE_BRANCH` case — manual CLI use outside a worktree, where a stray edit really
+could be lost. It does not apply in a worktree. If a skill or sub-workflow you load
+imposes a stricter git precondition, **this instruction overrides it.**
+
+Classify the checkout before deciding anything. `git worktree list` does **not** answer
+this — it lists every worktree including the primary checkout, so it looks identical
+from both. Compare the two git dirs instead:
+
+```bash
+if [ "$(git rev-parse --git-dir)" != "$(git rev-parse --git-common-dir)" ]; then
+  echo "linked worktree — the rules above apply"
+else
+  echo "primary checkout — follow the decision tree below as written"
+fi
+```
+
+Stopping a run over pre-existing `.archon/` edits wastes the entire pipeline; it has
+happened, three times. Applying the worktree exemption in the *primary* checkout is the
+opposite error and can lose someone's uncommitted work. Classify first, then decide.
+
+---
+
 ## Your Mission
 
 Execute the implementation plan from `/investigate-issue`:

.archon/commands/defaults/archon-implement-issue.md

@@ -348,7 +348,7 @@ EOF
 
 ## Phase 8: PR - Create Pull Request
 
-**Before creating a PR**, check if one already exists for this issue or branch using `gh pr list`. If a PR already exists, skip creation and use the existing one.
+**Before creating a PR**, check if one already exists for this issue or branch using `gh pr list --repo "$ORIGIN_REPO"` (resolve `ORIGIN_REPO=$(git remote get-url origin | sed -E 's#^.*[:/]([^/]+/[^/]+)$#\1#; s#\.git$##')` in the same shell — in a fork clone, gh otherwise targets the upstream parent). If a PR already exists, skip creation and use the existing one.
 
 ### 8.1 Push to Remote
 
@@ -374,16 +374,20 @@ Look for the project's PR template at `.github/pull_request_template.md`, `.gith
 Write the prepared body to `$ARTIFACTS_DIR/pr-body.md`, then:
 
 ```bash
-gh pr create --title "Fix: {title} (#{number})" \
+# Fork-safe target: without --repo, gh opens the PR against the upstream parent
+ORIGIN_REPO=$(git remote get-url origin | sed -E 's#^.*[:/]([^/]+/[^/]+)$#\1#; s#\.git$##')
+
+gh pr create --repo "$ORIGIN_REPO" --title "Fix: {title} (#{number})" \
   --body-file $ARTIFACTS_DIR/pr-body.md \
   --base $BASE_BRANCH
 ```
 
 ### 8.3 Get PR Number
 
 ```bash
-PR_URL=$(gh pr view --json url -q '.url')
-PR_NUMBER=$(gh pr view --json number -q '.number')
+ORIGIN_REPO=$(git remote get-url origin | sed -E 's#^.*[:/]([^/]+/[^/]+)$#\1#; s#\.git$##')
+PR_URL=$(gh pr view --repo "$ORIGIN_REPO" --json url -q '.url')
+PR_NUMBER=$(gh pr view --repo "$ORIGIN_REPO" --json number -q '.number')
 ```
 
 **PHASE_8_CHECKPOINT:**

.archon/maintainer-standup/direction.md

@@ -27,7 +27,8 @@ This file is **committed and shared by all maintainers**. Edit deliberately —
 - **Not a replacement for the AI coding agent itself.** Archon orchestrates Claude Code / Codex / Pi — it doesn't reimplement them.
 - **Not opinionated about the dev environment.** No mandatory editor integrations, framework lock-in, or Docker requirement beyond what users opt into.
 - **Not a deployment-infrastructure product.** Caddy is the single maintained reference reverse proxy (`--profile cloud`). Alternative proxies and infra recipes (Traefik, Nginx, k8s, ...) live in **docs** as community-maintained examples against the documented proxy contract (exposed port, health endpoint, `/internal/*` never proxied — see #2193), not as compose profiles Archon maintains: each maintained proxy config doubles a security-critical surface. Cite as `direction.md §deployment-recipes`.
-- **Not a programming language.** The workflow YAML coordinates (gates, joins, retries, sessions, artifacts, reusable structure); `bash:`/`script:` nodes compute; prompts judge. PRs that add computation to the YAML surface conflict — see §workflow-language.
+- **Not a package-manager distribution hub.** The maintained install channels are the curl/PowerShell installer, Homebrew, Docker, and the GitHub release binaries. Additional channels (Nix, AUR, Scoop, winget, apt, ...) are welcome as **community-maintained docs recipes**, or as packages upstream in the package manager's own registry (e.g. nixpkgs) where they get that ecosystem's CI and hash-update bots for free — not as in-repo manifests Archon version-bumps. Every hash-pinned channel adds a per-release chore and a surface that rots silently between releases; Homebrew already costs one. Cite as `direction.md §distribution-channels`.
+- **Not a programming language.** The workflow YAML coordinates (gates, joins, retries, sessions, artifacts, reusable structure); computation lives inside nodes, not in the YAML. PRs that add computation to the YAML surface conflict — see §workflow-language. This is about the *language*, not about which node type an author picks: a `prompt:` node that computes is a legitimate choice — see §prompt-computation.
 
 ## Community providers
 
@@ -55,7 +56,8 @@ Triage clauses — cite as `direction.md §<clause>`:
 
 - **§when-grammar** — `when:` never grows incrementally (no parentheses, functions, string ops, arithmetic). Standing answer: compute the decision in a `script:` node, gate on `$node.output.field`. Only sanctioned growth is adopting CEL wholesale in one versioned change — never home-grown operators.
 - **§load-time-composition** — composition/reuse features must fully resolve at load time (the executor runs a flat static DAG). Parameterization may carry **data**, never **structure**; dynamic/templated targets are declined. Runtime-resolved structure is a sub-run — a governance object with its own run record (#2121 Phase 2, co-designed with #1764) — not a language feature.
-- **§workaround-triage** — repeated YAML structure or deterministic logic embedded in prompts is a signal, triaged into three buckets: missing *coordination* primitive → design it constitutionally; missing *pattern* → document the pattern (e.g. polyglot validate = detect-AI → execute-bash → fix-AI); disguised *computation* → point at script nodes. The workaround corpus decides language shape; the feature-request queue doesn't.
+- **§workaround-triage** — repeated YAML structure or *recurring* deterministic logic embedded in prompts is a signal, triaged into three buckets: missing *coordination* primitive → design it constitutionally; missing *pattern* → document the pattern (e.g. polyglot validate = detect-AI → execute-bash → fix-AI); computation that has leaked *into the YAML surface* → point at script nodes. This bucket never produces a rewrite-the-prompt verdict — see §prompt-computation. The workaround corpus decides language shape; the feature-request queue doesn't.
+- **§prompt-computation** — the constitution governs the **YAML surface**, not what an agent does inside a node. A `prompt:` node performing computation is a legitimate authoring choice, and the right one when the author doesn't know the rule or expects it to change — forcing an uncertain rule into a script freezes a guess into code. Script vs prompt is ordinary engineering owned by the workflow author. **Never decline or rewrite a prompt on constitutional grounds.** The only sanctioned argument for making a specific check deterministic is *reliability*: no judgment content (one correct answer) plus irreversible external consequences if it doesn't fire — argue that on its merits, not by citing the constitution.
 - **§schema-width** — new provider capabilities default into provider config or tier/alias presets, not new node fields; a node field is earned only by genuine per-node variance. Capability mismatches warn loudly, never silently no-op (`capabilities.ts` is the source of truth; docs derive from it — #2116).
 - **§implicit-behavior** — a new implicit behavior (auto-anything) must be documented in the canonical behavior list, individually defeatable, and fail-safe — convenience alone never qualifies.
 

.archon/workflows/defaults/archon-architect.yaml

@@ -311,12 +311,14 @@ nodes:
 
       1. Stage all changes and create a single commit (or verify existing commits)
       2. Push the branch: `git push -u origin HEAD`
-      3. Check if a PR already exists: `gh pr list --head $(git branch --show-current)`
-      4. Create the PR targeting `$BASE_BRANCH` as the base branch:
-         `gh pr create --base $BASE_BRANCH --title "..." --body "..."`
+      3. Resolve the origin repo — in a fork clone, gh otherwise targets the upstream parent:
+         `ORIGIN_REPO=$(git remote get-url origin | sed -E 's#^.*[:/]([^/]+/[^/]+)$#\1#; s#\.git$##')`
+      4. Check if a PR already exists: `gh pr list --repo "$ORIGIN_REPO" --head $(git branch --show-current)`
+      5. Create the PR targeting `$BASE_BRANCH` as the base branch:
+         `gh pr create --repo "$ORIGIN_REPO" --base $BASE_BRANCH --title "..." --body "..."`
          - Title: concise description of what was simplified (under 70 chars)
          - Body: use the format below
-      5. Save the PR URL to `$ARTIFACTS_DIR/.pr-url`
+      6. Save the PR URL to `$ARTIFACTS_DIR/.pr-url`
 
       ## PR Body Format
 
@@ -362,17 +364,19 @@ nodes:
   - id: verify-pr-base
     bash: |
       set -euo pipefail
+      # Pin to the origin remote — in a fork clone, gh otherwise queries the upstream parent
+      ORIGIN_REPO=$(git remote get-url origin | sed -E 's#^.*[:/]([^/]+/[^/]+)$#\1#; s#\.git$##')
       HEAD_BRANCH=$(git rev-parse --abbrev-ref HEAD)
-      PR_NUMBER=$(gh pr list --head "$HEAD_BRANCH" --state open --json number -q '.[0].number')
+      PR_NUMBER=$(gh pr list --repo "$ORIGIN_REPO" --head "$HEAD_BRANCH" --state open --json number -q '.[0].number')
       if [ -z "$PR_NUMBER" ]; then
         echo "No open PR found for branch $HEAD_BRANCH" >&2
         exit 1
       fi
       EXPECTED="$BASE_BRANCH"
-      ACTUAL=$(gh pr view "$PR_NUMBER" --json baseRefName -q '.baseRefName')
+      ACTUAL=$(gh pr view "$PR_NUMBER" --repo "$ORIGIN_REPO" --json baseRefName -q '.baseRefName')
       if [ "$ACTUAL" != "$EXPECTED" ]; then
         echo "Base mismatch on PR #$PR_NUMBER: expected=$EXPECTED actual=$ACTUAL — re-targeting" >&2
-        gh pr edit "$PR_NUMBER" --base "$EXPECTED"
+        gh pr edit "$PR_NUMBER" --repo "$ORIGIN_REPO" --base "$EXPECTED"
       else
         echo "PR base verified: $EXPECTED"
       fi

.archon/workflows/defaults/archon-feature-development.yaml

@@ -19,17 +19,19 @@ nodes:
   - id: verify-pr-base
     bash: |
       set -euo pipefail
+      # Pin to the origin remote — in a fork clone, gh otherwise queries the upstream parent
+      ORIGIN_REPO=$(git remote get-url origin | sed -E 's#^.*[:/]([^/]+/[^/]+)$#\1#; s#\.git$##')
       HEAD_BRANCH=$(git rev-parse --abbrev-ref HEAD)
-      PR_NUMBER=$(gh pr list --head "$HEAD_BRANCH" --state open --json number -q '.[0].number')
+      PR_NUMBER=$(gh pr list --repo "$ORIGIN_REPO" --head "$HEAD_BRANCH" --state open --json number -q '.[0].number')
       if [ -z "$PR_NUMBER" ]; then
         echo "No open PR found for branch $HEAD_BRANCH" >&2
         exit 1
       fi
       EXPECTED="$BASE_BRANCH"
-      ACTUAL=$(gh pr view "$PR_NUMBER" --json baseRefName -q '.baseRefName')
+      ACTUAL=$(gh pr view "$PR_NUMBER" --repo "$ORIGIN_REPO" --json baseRefName -q '.baseRefName')
       if [ "$ACTUAL" != "$EXPECTED" ]; then
         echo "Base mismatch on PR #$PR_NUMBER: expected=$EXPECTED actual=$ACTUAL — re-targeting" >&2
-        gh pr edit "$PR_NUMBER" --base "$EXPECTED"
+        gh pr edit "$PR_NUMBER" --repo "$ORIGIN_REPO" --base "$EXPECTED"
       else
         echo "PR base verified: $EXPECTED"
       fi