toga-ai 1.0.13 → 1.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toga-ai",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "description": "TOGA Technology Team Claude Knowledge System — shared AI coding harness with skills, knowledge base CLI, and project installer for Claude Code.",
   "keywords": [
     "claude",

package/scripts/install.js

@@ -542,7 +542,6 @@ function main() {
 
   console.log('  Harness: npm bundle v' + bundleVersion);
   if (knowledgeDir !== PACKAGE_ROOT) {
-    const isInitOnly = (() => { try { const r = spawnSync('git', ['-C', knowledgeDir, 'remote', 'get-url', 'origin'], { stdio: 'pipe' }); return r.status === 0 && !gitUpdateLine; } catch { return false; } })();
     if (gitUpdateLine) {
       console.log('  Knowledge: git repo (' + gitUpdateLine.replace('git update: ', '') + ')');
     } else {

package/skills/capture/SKILL.md

@@ -33,30 +33,43 @@ validate + index succeed:
 - Doc types: `feature`, `client-feature`, `workflow`, `architecture` (elevated),
   `standard` (elevated).
 
-## Step 1 — Resolve the team-repo (`claude`) path
-
-Same resolution order as kickoff, but **push requires a real git clone** — flag clearly if
-only the installed `.claude/` bundle is found.
-
-Resolve in order:
-1. Claude memory `team-repo-path` — valid if path contains `knowledge/registry.json`
-2. Env var `CLAUDE_TEAM_REPO`
-3. Auto-discover — probe for `knowledge/registry.json` (NOT `knowledge/INDEX.md` — it's
-   auto-generated and absent in fresh clones) at these paths:
-   - `~/toga-tech` ← install.js clones here by default
-   - `~/claude`, `~/Documents/claude`, `~/Projects/claude`, `~/dev/claude`
-   - `C:\WWW\claude`, `D:\WWW\claude` (Windows)
-   - `./claude`, `../claude`, `../../claude`
-   - Walk up the directory tree from cwd
-   - `.claude/` in the current project (last resort — read-only, cannot push)
-4. Ask the developer
-
-If only `.claude/` is found — write docs there but warn before Step 7:
-> "⚠ No git clone found. Docs written locally but cannot push to GitHub.
-> Run: `git clone https://github.com/agilantsolutions/claude ~/toga-tech`
-> then re-run /capture to push."
-
-Persist a `team-repo-path` memory if missing. Call the helper as `node "<TEAM_REPO>/knowledge.js" …`.
+## Step 1 — Resolve TEAM_REPO and classify it
+
+Probe in order for a directory containing `knowledge/registry.json`. After finding it,
+immediately check if it is a real git clone. Set two variables you will use in every
+subsequent step:
+
+- `TEAM_REPO` — the resolved path
+- `IS_GIT_CLONE` — `true` if `git -C "<TEAM_REPO>" rev-parse --git-dir` exits 0
+
+**Probe order (stop at first hit):**
+```bash
+# 1. Claude memory — only accept if IS_GIT_CLONE is true
+#    (avoids re-using a stale .claude/ path from a previous session)
+# 2. Env var CLAUDE_TEAM_REPO
+# 3. Auto-discover (in this order):
+for p in ~/toga-tech ~/claude ~/Documents/claude ~/Projects/claude ~/dev/claude \
+          C:/WWW/claude D:/WWW/claude \
+          ./claude ../claude ../../claude; do
+  [ -f "$p/knowledge/registry.json" ] && echo "FOUND: $p" && break
+done
+# 4. Fallback: <project>/.claude/ — IS_GIT_CLONE will be false
+# 5. Ask the developer
+```
+
+**`~/toga-tech` must be probed first** — `npx toga-ai` runs `initLocalRepo` there, which
+creates a proper git repo seeded from the bundle even when the remote is private.
+
+**If `IS_GIT_CLONE` is false** (only `.claude/` bundle found): warn immediately and skip
+Steps 5–7 for git operations:
+> "⚠ No git clone found at standard paths. Docs will be written locally only.
+> Run `npx toga-ai` first (it creates `~/toga-tech` as a pushable git repo),
+> then re-run /capture to push to GitHub."
+
+**Persist** `team-repo-path` to Claude memory only when `IS_GIT_CLONE` is true — never
+persist the `.claude/` bundle path, or the next session will silently skip pushing again.
+
+Call the helper as `node "<TEAM_REPO>/knowledge.js" …`.
 
 ## Step 2 — Determine framework / repo / project (ask if unknown)
 
@@ -98,89 +111,67 @@ Ask the developer to approve. They may accept all, accept some, or edit. **Write
 until they confirm.** If a needed placement detail is ambiguous (which client? new vs.
 update?), ask before proposing.
 
-## Step 5 — Apply the approved changes
+## Step 5 — Apply approved changes (write to TEAM_REPO, not .claude/)
 
-Write/update/remove docs using the templates below. For every doc set/refresh frontmatter:
-`framework`, `repo` (omit for pure client docs), `project`, `client` (`shared` for app docs;
-a real slug for client docs), `type`, `status`, `updated` (today's date), `owners`, `files`,
-`related`. Add `related:` cross-links (a `client-feature` must link back to the shared
-`apps/<repo>/features/<base>.md`). If a new repo was onboarded, append it to `registry.json`.
+Write all docs to `<TEAM_REPO>/knowledge/...` — the git clone, not the project bundle.
+**Never write to `<project>/.claude/knowledge/` when a git clone exists.**
 
-## Step 6 — Re-index and guard integrity (mandatory)
+For every doc, set/refresh frontmatter: `framework`, `repo`, `project`, `client`,
+`type`, `status`, `updated` (today's date), `owners`, `files`, `related`.
+Add `related:` cross-links. Append new repos to `<TEAM_REPO>/knowledge/registry.json`.
 
-```
-node "<TEAM_REPO>/knowledge.js" index
+## Step 6 — Validate, index, mirror back (mandatory)
+
+```bash
 node "<TEAM_REPO>/knowledge.js" validate
+node "<TEAM_REPO>/knowledge.js" index
 ```
 
-`index` rebuilds all `INDEX.md` files from frontmatter (never hand-edit them). If `validate`
-reports any error, **stop and fix it** before telling the developer you're done — do not
-report success on an inconsistent knowledge base.
+If `validate` reports any ERROR — stop and fix before continuing.
 
-## Step 7 — Auto-push to share with teammates
+After both pass, **mirror back** to keep the project's local reads fresh:
+```bash
+# Only when TEAM_REPO != <project>/.claude
+cp -r "<TEAM_REPO>/knowledge/" "<project>/.claude/knowledge/"
+```
+Skip mirror-back if the paths are the same directory.
 
-After validate + index succeed, run through these checks in order before pushing.
-**Never skip straight to the push — the repo must be verified first.**
+## Step 7 — Push (only when IS_GIT_CLONE is true)
 
-### Pre-push checklist (run each check, stop at the first failure and fix it)
+If `IS_GIT_CLONE` is false — skip this step entirely and show:
+> "⚠ Docs written to `.claude/knowledge/` only (no git clone). Run `npx toga-ai`
+> to create `~/toga-tech`, then re-run /capture to push."
 
-**Check 1 — Is TEAM_REPO a git repository?**
-```bash
-git -C "<TEAM_REPO>" rev-parse --is-inside-work-tree
-```
-If this fails: the team repo is an npm bundle extract, not a git clone. Run:
-```bash
-git clone https://github.com/agilantsolutions/claude "<TEAM_REPO>"
-```
-Then re-run validate + index inside the freshly cloned repo before continuing.
+Otherwise:
 
-**Check 2 — Is origin set to the right remote?**
+**Check A — origin URL correct?**
 ```bash
 git -C "<TEAM_REPO>" remote get-url origin
 ```
-Expected: `https://github.com/agilantsolutions/claude` (or the SSH equivalent).
 If wrong or missing: `git -C "<TEAM_REPO>" remote set-url origin https://github.com/agilantsolutions/claude`
 
-**Check 3 — Are the knowledge docs in TEAM_REPO, not just the project?**
-
-The docs you wrote in Steps 5–6 must exist inside `<TEAM_REPO>/knowledge/`, not only
-in `<project>/.claude/knowledge/`. If you wrote them to the project's `.claude/knowledge/`
-but not to `<TEAM_REPO>/knowledge/`, copy them now:
-```bash
-# Example — adjust paths to match what was written
-cp "<project>/.claude/knowledge/<path-to-doc>" "<TEAM_REPO>/knowledge/<path-to-doc>"
-```
-Then re-run `node "<TEAM_REPO>/knowledge.js" validate` to confirm they're valid there too.
-
-**Check 4 — Are there actually staged changes to push?**
+**Check B — anything new to push?**
 ```bash
 git -C "<TEAM_REPO>" status --short knowledge/
 ```
-If nothing shows: the docs were never written to TEAM_REPO. Go back to Check 3.
-
----
-
-### Push (only after all 4 checks pass)
+If empty — report "No new knowledge to push" and exit cleanly.
 
+**Push:**
 ```bash
-# Stage only knowledge/ — never stage anything else
 git -C "<TEAM_REPO>" add knowledge/
 git -C "<TEAM_REPO>" diff --cached --quiet || \
-  git -C "<TEAM_REPO>" commit -m "knowledge: <brief description of what was captured>"
-
-# Push to the active development branch
+  git -C "<TEAM_REPO>" commit -m "knowledge: <one-line summary>"
 git -C "<TEAM_REPO>" push origin HEAD:feature/ai-harness-improvements
 ```
 
-**If push succeeds:** report
-> "✓ Knowledge pushed to `feature/ai-harness-improvements` — CI will publish a new npm version. Teammates get it on their next `npx toga-ai`."
+Never stage files outside `knowledge/`. If `git diff --cached` includes anything outside
+`knowledge/`, abort and warn before committing.
 
-**If push fails** — show the developer the exact git error output, then report:
-> "⚠ Push failed: `<error>`. Fix credentials or run manually:
-> `git -C <TEAM_REPO> push origin HEAD:feature/ai-harness-improvements`"
+**If push succeeds:**
+> "✓ Pushed to `feature/ai-harness-improvements` — CI publishes new npm version. Teammates get it on `npx toga-ai`."
 
-Never stage anything outside `knowledge/`. If `git diff --cached` shows files outside
-`knowledge/`, abort and warn before committing.
+**If push fails** — show exact git error, then:
+> "⚠ Push failed: `<error>`. Run manually: `git -C <TEAM_REPO> push origin HEAD:feature/ai-harness-improvements`"
 
 ## Step 8 — Report