Reach your own rig through $MY_RIG_PATH instead of retyping its name

Every command that touched a participant's own rig spelled the path out as
$SFI_PATH/<your-rig-name>, so the placeholder had to be hand-substituted 34
times across five pages. L1 step 1 now exports $MY_RIG_PATH beside the
gc rig add that creates the rig, and appends it to a shell rc so a Day 2
terminal still has it.

The 16 --rig <your-rig-name> uses are left alone: that argument takes the
rig's name, not its path.

City: city · Agent: local-core.builder-1

Author: austinborn

bootstrap/README.md

@@ -61,7 +61,7 @@ Runs the setup work for 00.1, 00.2 and 00.3 on the way past, then stops at the e
 
 **Mental model:** `./bootstrap.sh <step>` answers "make my factory look like I just finished `<step>`," not "make my factory ready for me to start `<step>`."
 
-**Nothing to paste afterwards.** `$SFI_PATH` is the only path variable the curriculum asks for, and [W2](../progression/W2-cloud-box-and-preflight.md) and [W3](../progression/W3-run-your-factory.md) both append it to a shell rc. The script works out the factory, rig and artifact directories from it for its own use; every page writes them out the same way, so a run leaves your shell with nothing new to set.
+**Nothing to paste afterwards.** `$SFI_PATH` is the only path variable this script needs, and [W2](../progression/W2-cloud-box-and-preflight.md) and [W3](../progression/W3-run-your-factory.md) both append it to a shell rc. The script works out the factory, rig and artifact directories from it for its own use; every page writes them out the same way, so a run leaves your shell with nothing new to set. The curriculum asks for a second one later, `$MY_RIG_PATH`, which [L1 step 1](../progression/L1-plan-your-factory.md#1-register-your-repo-as-a-rig) sets and persists. Every step this script rebuilds sits before that point.
 
 ## About the Bootstrap Script
 

hardening/05-self-improvement-loop.md

@@ -28,7 +28,7 @@ Close the loop: your factory reads a signal it already produces, proposes a chan
 - [W3](../progression/W3-run-your-factory.md) complete, and a factory that has been running long enough to have produced some evidence about itself.
 - [W4](../progression/W4-tour-the-factory.md) complete, because the proposal will land in one of the layers and you need to be able to name which.
 - Your [capability map](../progression/L2-capability-map.md) open.
-- `$SFI_PATH` set in your shell. [W2](../progression/W2-cloud-box-and-preflight.md) and [W3](../progression/W3-run-your-factory.md) both append it to a shell rc, so it survives a new terminal. Every other path on this page is written out from it.
+- `$SFI_PATH` and `$MY_RIG_PATH` set in your shell. [W2](../progression/W2-cloud-box-and-preflight.md) and [W3](../progression/W3-run-your-factory.md) append the first to a shell rc, [L1 step 1](../progression/L1-plan-your-factory.md#1-register-your-repo-as-a-rig) the second, so both survive a new terminal. Every other path on this page is written out from them.
 
 **This option needs no other option.** It is a loop rather than a pack: nothing to install, and the signals it reads are ones your base factory already writes. Any other option you have installed gives it a richer signal, and none of them is required.
 
@@ -55,7 +55,7 @@ You do not need new instrumentation. Your factory has been writing evidence abou
 **Copy and paste**
 
 ```bash
-cd "$SFI_PATH/<your-rig-name>"
+cd "$MY_RIG_PATH"
 ls -la docs/reviews/ 2>/dev/null                 # per-principle scores, if you took that option
 bd list --status blocked --json | jq -r '.[] | "\(.id)  \(.metadata.bead_review_feedback // .metadata.blocker_reason // "")"'
 cd "$SFI_PATH/factory1"
@@ -93,7 +93,7 @@ Now ask for a proposal in a shape you can act on. A proposal that names a file a
 Ask the mayor to write its proposal as a bead, so it lands somewhere durable rather than in a tmux buffer:
 
 ```bash
-cd "$SFI_PATH/<your-rig-name>"
+cd "$MY_RIG_PATH"
 bd create --title "Proposal: <the change, in one line>" \
   --description "Signal: <what the factory observed about itself, with counts>.
 Layer: <agent | formula | order>.
@@ -145,7 +145,7 @@ Merging it is optional. Having a proposal that survived your own gate is the del
 ## Verification
 
 ```bash
-cd "$SFI_PATH/<your-rig-name>"
+cd "$MY_RIG_PATH"
 bd list --json | jq -r '.[] | select(.title | startswith("Proposal:")) | "\(.id)  \(.status)"'
 ```
 

progression/L1-plan-your-factory.md

@@ -30,7 +30,7 @@ That set of documents is the input to [L2](./L2-capability-map.md), which starts
 
 - [W3](./W3-run-your-factory.md) through [W5](./W5-observability.md) complete: a working factory you can read.
 - A repository you can push to and are willing to let a factory open pull requests against. A personal project or a fork is ideal. A repository you do not control is not.
-- `$SFI_PATH` set in your shell. [W2](./W2-cloud-box-and-preflight.md) and [W3](./W3-run-your-factory.md) both append it to a shell rc, so it survives a new terminal. Every other path on this page is written out from it.
+- `$SFI_PATH` set in your shell. [W2](./W2-cloud-box-and-preflight.md) and [W3](./W3-run-your-factory.md) both append it to a shell rc, so it survives a new terminal. Step 1 derives `$MY_RIG_PATH` from it and persists that the same way; between them those two write out every path on this page.
 
 ## Context
 
@@ -60,7 +60,8 @@ Register the rig as a **sibling** of the city, the same shape [W3](./W3-run-your
 cd "$SFI_PATH/factory1"
 git clone <your-repo-url> ../<your-rig-name>
 gc rig add ../<your-rig-name> <your-rig-name>
-ls "$SFI_PATH/<your-rig-name>"
+export MY_RIG_PATH="$SFI_PATH/<your-rig-name>"
+ls "$MY_RIG_PATH"
 gc rig list
 ```
 
@@ -70,6 +71,26 @@ gc rig list
 your rig listed alongside ascii-art, with a path and a prefix
 ```
 
+That `export` is the last time you write your rig's path out by hand. Every page from here reaches it through `$MY_RIG_PATH` instead. Commands taking `--rig` still want the rig's *name*, which is a different thing and stays literal.
+
+Now make the variable survive a new terminal, the same way [W2](./W2-cloud-box-and-preflight.md) made `$SFI_PATH` survive one. Append it to the rc file for your shell, on the machine your factory runs on:
+
+**Copy and paste** (macOS / zsh)
+
+```bash
+cat <<EOF >> ~/.zshrc
+export MY_RIG_PATH="$MY_RIG_PATH"
+EOF
+```
+
+**Copy and paste** (Linux / bash, including the cloud box)
+
+```bash
+cat <<EOF >> ~/.bashrc
+export MY_RIG_PATH="$MY_RIG_PATH"
+EOF
+```
+
 Then install the base factory into it, so your own rig has the same machinery `ascii-art` does:
 
 **Copy and paste**
@@ -86,9 +107,9 @@ A **project overview** is a loosely structured document answering a few question
 **Copy and paste**
 
 ```bash
-mkdir -p "$SFI_PATH/<your-rig-name>/docs/current"
-cp "$SFI_PATH/sf-tutorial/artifacts/docs/PROJECT_OVERVIEW.template.md" "$SFI_PATH/<your-rig-name>/docs/PROJECT_OVERVIEW.md"
-nano "$SFI_PATH/<your-rig-name>/docs/PROJECT_OVERVIEW.md"
+mkdir -p "$MY_RIG_PATH/docs/current"
+cp "$SFI_PATH/sf-tutorial/artifacts/docs/PROJECT_OVERVIEW.template.md" "$MY_RIG_PATH/docs/PROJECT_OVERVIEW.md"
+nano "$MY_RIG_PATH/docs/PROJECT_OVERVIEW.md"
 ```
 
 `nano` ships with the box and is not modal: `Ctrl-O` then `Enter` saves, `Ctrl-X` exits. Use a different editor if you prefer one.
@@ -98,7 +119,7 @@ nano "$SFI_PATH/<your-rig-name>/docs/PROJECT_OVERVIEW.md"
 Install the [Manifest Generator skill](https://github.com/audiojak/manifest-generator):
 
 ```bash
-cd "$SFI_PATH/<your-rig-name>/docs"
+cd "$MY_RIG_PATH/docs"
 npx skills add https://github.com/audiojak/manifest-generator
 ```
 
@@ -124,7 +145,7 @@ The second one is the one people skip and then need. It is the document your cap
 **Copy and paste**
 
 ```bash
-cd "$SFI_PATH/<your-rig-name>"
+cd "$MY_RIG_PATH"
 bd status
 ```
 
@@ -146,7 +167,7 @@ gc sling --rig <your-rig-name> polecat <the-third-bead-id>
 Then watch it, from your own rig:
 
 ```bash
-cd "$SFI_PATH/<your-rig-name>"
+cd "$MY_RIG_PATH"
 bd show <the-third-bead-id> --json | jq '.[0] | {status, assignee, metadata}'
 ```
 
@@ -165,9 +186,9 @@ You have a factory pointed at real work and two documents describing what that w
 ```bash
 gc rig list
 gc import list --rig <your-rig-name>
-test -f "$SFI_PATH/<your-rig-name>/docs/PROJECT_MANIFEST.md" && echo "project manifest: present"
-test -f "$SFI_PATH/<your-rig-name>/docs/SOFTWARE_FACTORY_MANIFEST.md" && echo "factory manifest: present"
-cd "$SFI_PATH/<your-rig-name>" && bd list --status open
+test -f "$MY_RIG_PATH/docs/PROJECT_MANIFEST.md" && echo "project manifest: present"
+test -f "$MY_RIG_PATH/docs/SOFTWARE_FACTORY_MANIFEST.md" && echo "factory manifest: present"
+cd "$MY_RIG_PATH" && bd list --status open
 ```
 
 ## Ceiling

progression/L2-capability-map.md

@@ -49,8 +49,8 @@ Thirty minutes at the end of Day 1 to get the rows down, and thirty on Day 2 mor
 **Copy and paste**
 
 ```bash
-cp "$SFI_PATH/sf-tutorial/artifacts/docs/capability-map.template.md" "$SFI_PATH/<your-rig-name>/docs/current/capability-map.md"
-nano "$SFI_PATH/<your-rig-name>/docs/current/capability-map.md"
+cp "$SFI_PATH/sf-tutorial/artifacts/docs/capability-map.template.md" "$MY_RIG_PATH/docs/current/capability-map.md"
+nano "$MY_RIG_PATH/docs/current/capability-map.md"
 ```
 
 One row per change you want to make. Each row names the change, which layer it touches, what it costs, and how you will know it worked.
@@ -86,14 +86,14 @@ A useful tiebreak: rank by how much you would trust the factory afterwards, not
 Commit it:
 
 ```bash
-cd "$SFI_PATH/<your-rig-name>"
+cd "$MY_RIG_PATH"
 git add docs/current/capability-map.md
 git commit -m "Add capability map for factory changes"
 ```
 
 ### 4. Day 2: finish and review
 
-Come back to the map with a night's distance. A new shell only needs `$SFI_PATH`, which [W2](./W2-cloud-box-and-preflight.md) and [W3](./W3-run-your-factory.md) both append to a shell rc; every path on this page and in the labs that follow is written out from it.
+Come back to the map with a night's distance. A new shell needs `$SFI_PATH` and `$MY_RIG_PATH`. [W2](./W2-cloud-box-and-preflight.md) and [W3](./W3-run-your-factory.md) append the first to a shell rc and [L1 step 1](./L1-plan-your-factory.md#1-register-your-repo-as-a-rig) appends the second, so a Day 2 terminal opens with both; every path on this page and in the labs that follow is written out from them.
 
 Then three things to do, in order:
 
@@ -114,9 +114,9 @@ The map is a factory design document that took two days of contact to write and
 ## Verification
 
 ```bash
-test -f "$SFI_PATH/<your-rig-name>/docs/current/capability-map.md" && echo "capability map: present"
-grep -c '^|' "$SFI_PATH/<your-rig-name>/docs/current/capability-map.md"
-cd "$SFI_PATH/<your-rig-name>" && git log --oneline -1 -- docs/current/capability-map.md
+test -f "$MY_RIG_PATH/docs/current/capability-map.md" && echo "capability map: present"
+grep -c '^|' "$MY_RIG_PATH/docs/current/capability-map.md"
+cd "$MY_RIG_PATH" && git log --oneline -1 -- docs/current/capability-map.md
 ```
 
 **Expected output**

progression/L3-L5-feature-labs.md

@@ -66,13 +66,14 @@ Every command below is written out from two variables:
 | Variable | Points at | Set by |
 | --- | --- | --- |
 | `SFI_PATH` | your workspace directory | [W2](./W2-cloud-box-and-preflight.md) on your laptop, [W3 step 3](./W3-run-your-factory.md#3-open-a-shell-on-the-box) on the box. Both append it to a shell rc, so it survives |
+| `MY_RIG_PATH` | your own rig's directory | [L1 step 1](./L1-plan-your-factory.md#1-register-your-repo-as-a-rig), which appends it to a shell rc too |
 
-Your factory is `$SFI_PATH/factory1` and your own rig is `$SFI_PATH/<your-rig-name>`. Nothing on this page asks you to export either.
+Your factory is `$SFI_PATH/factory1` and your own rig is `$MY_RIG_PATH`. Nothing on this page asks you to export either; both were set and persisted on the pages that created them.
 
 **Copy and paste**
 
 ```bash
-cd "$SFI_PATH/factory1" && gc rig list && ls "$SFI_PATH/<your-rig-name>"
+cd "$SFI_PATH/factory1" && gc rig list && ls "$MY_RIG_PATH"
 ```
 
 **Expected output**
@@ -91,7 +92,7 @@ If `gc rig list` comes back without your rig, or the `ls` cannot find the direct
 **Copy and paste**
 
 ```bash
-cd "$SFI_PATH/<your-rig-name>"
+cd "$MY_RIG_PATH"
 cat docs/current/capability-map.md
 ```
 
@@ -166,21 +167,21 @@ Run the verification you wrote in the map's own column, not a different one that
 **Copy and paste**
 
 ```bash
-cd "$SFI_PATH/<your-rig-name>"
+cd "$MY_RIG_PATH"
 bd create --title "<a bead that exercises the change>" --type task --priority 2
 cd "$SFI_PATH/factory1"
 gc sling --rig <your-rig-name> polecat <the-new-bead-id>
-watch -n 5 'cd '"$SFI_PATH/<your-rig-name>"' && bd show <the-new-bead-id> --json | jq -r ".[0] | \"\(.status)  \(.assignee)\""'
+watch -n 5 'cd '"$MY_RIG_PATH"' && bd show <the-new-bead-id> --json | jq -r ".[0] | \"\(.status)  \(.assignee)\""'
 ```
 
 The important part is the negative case. **A gate you have only seen pass is a gate you have not tested.** Construct the input that *should* be rejected and confirm it is:
 
 ```bash
-cd "$SFI_PATH/<your-rig-name>"
+cd "$MY_RIG_PATH"
 bd create --title "<a bead your change should reject or catch>" --type task --priority 3
 cd "$SFI_PATH/factory1"
 gc sling --rig <your-rig-name> polecat <that-bead-id>
-cd "$SFI_PATH/<your-rig-name>"
+cd "$MY_RIG_PATH"
 bd show <that-bead-id> --json | jq -r '.[0] | .status, (.metadata.blocker_reason // "no blocker recorded")'
 ```
 
@@ -258,7 +259,7 @@ If you install that option, its formula is also the one to cook when you want to
 cd "$SFI_PATH/factory1"
 gc formula list
 gc formula cook <a-formula-name> --rig <your-rig-name>
-cd "$SFI_PATH/<your-rig-name>"
+cd "$MY_RIG_PATH"
 bd list --json | jq -r '.[] | "\(.id)  kind=\(.metadata."gc.kind" // "-")  routed=\(.metadata."gc.routed_to" // "-")  \(.title)"'
 ```
 
@@ -312,7 +313,7 @@ Across the three slots: at least one shipped option installed and working in you
 cd "$SFI_PATH/factory1"
 gc import list --rig <your-rig-name>
 gc doctor
-cd "$SFI_PATH/<your-rig-name>"
+cd "$MY_RIG_PATH"
 git log --oneline -3
 bd list --status blocked
 ```
@@ -331,7 +332,7 @@ the bead you deliberately made fail, still blocked with a reason
 - **The option's page refers to agents you do not have.** Each option page assumes the base factory plus that option. If it names an agent from a different option, you found a bug worth reporting; the options are meant to be independent.
 - **`gc import add` succeeds and the new agent never appears.** Check the scope. Options install at rig scope with `--rig`; installing at city scope puts the agent somewhere the rig cannot see.
 - **You installed from a URL and the agent never appears.** Run `gc import install`. A remote import is recorded by `gc import add` and fetched by `gc import install`, and until the fetch happens there is nothing on disk for `gc reload` to read.
-- **A command runs somewhere unexpected, or `ls` reports `cannot access '': No such file or directory`.** `$SFI_PATH` is unset in this shell. `cd ""` exits 0 in both bash and zsh, so an unset variable leaves you where you were rather than reporting an error. `echo "$SFI_PATH"` settles it; [W2](./W2-cloud-box-and-preflight.md) and [W3](./W3-run-your-factory.md) both append it to a shell rc, so a Day 2 shell that has lost it never ran that step.
+- **A command runs somewhere unexpected, or `ls` reports `cannot access '': No such file or directory`.** `$SFI_PATH` or `$MY_RIG_PATH` is unset in this shell. `cd ""` exits 0 in both bash and zsh, so an unset variable leaves you where you were rather than reporting an error. `echo "$SFI_PATH" "$MY_RIG_PATH"` settles it; [W2](./W2-cloud-box-and-preflight.md) and [W3](./W3-run-your-factory.md) append the first to a shell rc and [L1 step 1](./L1-plan-your-factory.md#1-register-your-repo-as-a-rig) appends the second, so a Day 2 shell missing either never ran that step.
 - **Your change works on `ascii-art` and not on your rig.** Your rig needs the base factory imported too — L1 step 1. `gc import list --rig <your-rig-name>` settles it.
 - **The negative case passes when it should fail.** Either the input was better-formed than you thought, or the check is not on the path the bead took. Both are worth a map row.
 

progression/W6-advanced-concepts.md

@@ -36,7 +36,7 @@ Three ideas that only become interesting once a factory has been running for a w
 
 - A factory from [W3](./W3-run-your-factory.md): the base factory installed on a rig of your own. That is the whole prerequisite, and every command on this page runs against it. A slot already spent in [L3](./L3-L5-feature-labs.md) gives part 1 more history to read, which makes for a better demonstration.
 - Your capability map to hand.
-- `$SFI_PATH` set in your shell. [W2](./W2-cloud-box-and-preflight.md) and [W3](./W3-run-your-factory.md) both append it to a shell rc, so it survives a new terminal. Every other path on this page is written out from it.
+- `$SFI_PATH` and `$MY_RIG_PATH` set in your shell. [W2](./W2-cloud-box-and-preflight.md) and [W3](./W3-run-your-factory.md) append the first to a shell rc, [L1 step 1](./L1-plan-your-factory.md#1-register-your-repo-as-a-rig) the second, so both survive a new terminal. Every other path on this page is written out from them.
 
 ## Part 1: Self-improvement loops
 
@@ -85,7 +85,7 @@ So the loop has four parts and the fourth is not optional: read a signal, find a
 **Copy and paste**
 
 ```bash
-cd "$SFI_PATH/<your-rig-name>"
+cd "$MY_RIG_PATH"
 bd list --status blocked --json | jq -r '.[] | "\(.id)  \(.metadata.blocker_reason // "")"'
 cd "$SFI_PATH/factory1"
 gc order history
@@ -175,14 +175,14 @@ You have been in contact with a factory for a day and a half. Something in that
 **Copy and paste**
 
 ```bash
-mkdir -p "$SFI_PATH/<your-rig-name>/docs/current"
-nano "$SFI_PATH/<your-rig-name>/docs/current/findings.md"
+mkdir -p "$MY_RIG_PATH/docs/current"
+nano "$MY_RIG_PATH/docs/current/findings.md"
 ```
 
 Write one finding, in this shape: what you expected, what happened, what you would tell the next person. Three sentences is a complete entry. Then commit it:
 
 ```bash
-cd "$SFI_PATH/<your-rig-name>"
+cd "$MY_RIG_PATH"
 git add docs/current/findings.md
 git commit -m "Record first factory findings"
 ```
@@ -285,7 +285,7 @@ Rig scope, and it sits directly on the base factory. Now write a bead that descr
 **Copy and paste**
 
 ```bash
-cd "$SFI_PATH/<your-rig-name>"
+cd "$MY_RIG_PATH"
 bd create --title "Add row-level security to the reports table" --type task --priority 2 \
   -d "Scope every read of the reports table to the caller's tenant."
 cd "$SFI_PATH/factory1"
@@ -336,7 +336,7 @@ None of it is exotic machinery. Each one is an order, a fragment or a formula, a
 cd "$SFI_PATH/factory1"
 gc order list
 gc order history
-cd "$SFI_PATH/<your-rig-name>"
+cd "$MY_RIG_PATH"
 bd list --status blocked
 test -f docs/current/findings.md && echo "findings: present"
 ```