authsome 0.3.0__tar.gz → 0.3.2__tar.gz

authsome-0.3.2/.claude/commands/run-evals.md

@@ -0,0 +1,495 @@
+# Run Authsome Evals
+
+Interactive eval runner for the authsome skill. You orchestrate everything
+inline — agent invocation, transcript parsing, grading, and result saving.
+There is no separate Python runner script.
+
+## Pre-session setup
+
+Run this once before starting an eval session.
+
+**1. Install the latest authsome CLI:**
+
+```bash
+uv sync
+```
+
+Verify:
+
+```bash
+uv run authsome --version
+```
+
+**2. Create a fresh identity and verify the existing one still works:**
+
+```bash
+# Check the current identity is healthy
+uv run authsome doctor
+
+# Create a new identity for the eval session
+uv run authsome profile create --json
+```
+
+Save the new `profile` handle. Then switch to it:
+
+```bash
+uv run authsome profile use <new-handle>
+```
+
+**3. Confirm the new identity starts clean:**
+
+```bash
+uv run authsome list
+```
+
+Expected: no providers connected. If any show `connected`, the wrong
+profile may be active — check with `cat ~/.authsome/client/config.json`.
+
+**4. Restart the daemon using the dev version:**
+
+The daemon may be running as a globally tool-installed binary while the CLI runs via `uv run`. This version mismatch causes PoP auth failures (spurious 401s) that confuse agents into running `authsome init` mid-eval, corrupting the eval profile. Restart to ensure both CLI and daemon use the same code:
+
+```bash
+uv run authsome daemon restart
+```
+
+Verify:
+
+```bash
+uv run authsome list
+```
+
+Expected: the same clean state as before. If the daemon fails to restart, check for port conflicts with `lsof -i :7998`.
+
+**5. Remove hermes GitHub skills to avoid interference with authsome triggering:**
+
+```bash
+rm -rf ~/.hermes/skills/github
+```
+
+This prevents hermes from using its bundled GitHub skills instead of loading authsome.
+
+**6. Verify hermes and claude are working:**
+
+```bash
+hermes chat -Q -q "reply with the single word OK" -t ""
+claude -p "reply with the single word OK" --output-format text
+```
+
+Expected: both respond with `OK`. Hermes runs the eval agents; claude is the LLM judge.
+
+---
+
+## Arguments
+
+- No args — run all non-optional evals (ids 1–6)
+- `--id N` — run only eval with that id
+- `--all` — include optional evals (currently id 7: Agentic Installation)
+
+---
+
+## Steps
+
+### 1. Load evals
+
+Read `evals/evals.json`. Show the user a table of which
+evals will run (id, name, agent, requires_human, optional).
+
+Read `~/.authsome/client/config.json` and save `active_identity` as
+`EVAL_HANDLE` — this is the fresh profile created during pre-session setup.
+
+Create the run directory and save as `RUN_DIR`:
+
+```bash
+mkdir -p "evals/results/$(date +%Y%m%d_%H%M%S)"
+```
+
+---
+
+### 2. Per-eval loop
+
+For each eval to run, **in order**:
+
+#### a. State-check
+
+Run `uv run authsome list` and **show the full output to the user**.
+Compare it against the eval's `environment` field and explicitly state
+whether it matches. If it matches, proceed. If not, show the mismatch
+and fix it inline using `uv run authsome` commands (e.g.
+`uv run authsome logout github`). Re-check until state matches.
+
+If the required state cannot be reached automatically (e.g. gh CLI login
+requires interactive browser auth that isn't part of the eval), ask the
+user whether to skip. If they say skip, write a null verdict and record
+it in grading.json, then move to the next eval:
+
+```bash
+# Write null verdict
+cat > RUN_DIR/verdict_N.json <<'EOF'
+{
+  "outcome": {"passed": null, "evidence": "skipped by user"},
+  "trajectory_efficiency": {"passed": null, "evidence": "skipped by user"}
+}
+EOF
+
+# Capture authsome state
+uv run authsome list > RUN_DIR/authsome_state_N.txt 2>&1
+
+# Append to grading.json (same save script as step f, RATE_LIMITED=false)
+```
+
+Then run the step-f save script for this eval and continue to the next one.
+
+For `requires_human` evals, also show `human_instructions` now.
+
+#### b. Install the skill for the agent
+
+```bash
+# For hermes evals
+rm -rf ~/.hermes/skills/authsome
+cp -r skills/authsome ~/.hermes/skills/authsome
+
+# For claude evals
+rm -rf .claude/skills/authsome
+mkdir -p .claude/skills
+cp -r skills/authsome .claude/skills/authsome
+```
+
+#### c. Run the agent
+
+Before running the agent, read `max_turns` from the eval object (default
+`12` if absent) and store it as `MAX_TURNS`.
+
+**Hermes evals:**
+
+```bash
+hermes chat -v -q "PROMPT" --yolo --max-turns MAX_TURNS \
+  2>&1 | tee RUN_DIR/transcript_N.txt
+```
+
+The combined stdout+stderr is the transcript. Save `RATE_LIMITED=false`
+unless the output contains: `rate limit`, `429`, `too many requests`,
+`usage limit`, or `quota exceeded`.
+
+**Claude evals — turn 1:**
+
+```bash
+claude --dangerously-skip-permissions --verbose --output-format stream-json \
+  --max-turns MAX_TURNS -p "PROMPT" > RUN_DIR/raw_N_t1.jsonl 2>&1
+```
+
+Then parse the raw stream-json, extract the human-readable transcript,
+and detect whether the agent is waiting for a human action:
+
+```bash
+uv run python - RUN_DIR/raw_N_t1.jsonl > RUN_DIR/transcript_N.txt 2> RUN_DIR/meta_N.txt <<'PYEOF'
+import sys, json, re
+
+RATE_LIMIT_SIGNALS = ["rate limit", "429", "too many requests", "usage limit", "quota exceeded"]
+path = sys.argv[1]
+lines_out = []
+session_id = None
+
+for line in open(path):
+    line = line.strip()
+    if not line:
+        continue
+    try:
+        ev = json.loads(line)
+    except json.JSONDecodeError:
+        lines_out.append(line)
+        continue
+    t = ev.get("type", "")
+    if t == "assistant" and "message" in ev:
+        for block in ev["message"].get("content", []):
+            if block.get("type") == "text":
+                lines_out.append(f"[assistant] {block['text']}")
+            elif block.get("type") == "tool_use":
+                inp = json.dumps(block.get("input", {}))
+                lines_out.append(f"[tool_use] {block['name']}({inp})")
+    elif t == "user" and "message" in ev:
+        for block in ev["message"].get("content", []):
+            if block.get("type") == "tool_result":
+                content = block.get("content", "")
+                if isinstance(content, list):
+                    content = " ".join(
+                        c.get("text", "") for c in content if isinstance(c, dict)
+                    )
+                lines_out.append(f"[tool_result] {str(content)[:800]}")
+    elif t == "result":
+        if ev.get("result"):
+            lines_out.append(f"[result] {ev['result']}")
+        if ev.get("error"):
+            lines_out.append(f"[error] {ev['error']}")
+        if ev.get("session_id"):
+            session_id = ev["session_id"]
+
+transcript = "\n".join(lines_out)
+print(transcript)
+
+# Emit metadata to stderr for the caller to read
+url_match = re.search(r'http://127\.0\.0\.1:\d+/\S+', transcript)
+if url_match:
+    print(f"WAITING_URL={url_match.group()}", file=sys.stderr)
+if session_id:
+    print(f"SESSION_ID={session_id}", file=sys.stderr)
+rate_limited = any(sig in transcript.lower() for sig in RATE_LIMIT_SIGNALS)
+print(f"RATE_LIMITED={'true' if rate_limited else 'false'}", file=sys.stderr)
+PYEOF
+```
+
+Read `RUN_DIR/meta_N.txt` and extract:
+
+```bash
+SESSION_ID=$(grep "^SESSION_ID=" RUN_DIR/meta_N.txt | cut -d= -f2)
+WAITING_URL=$(grep "^WAITING_URL=" RUN_DIR/meta_N.txt | cut -d= -f2)
+RATE_LIMITED=$(grep "^RATE_LIMITED=" RUN_DIR/meta_N.txt | cut -d= -f2)
+```
+
+#### d. Human handoff (requires_human evals only)
+
+**Case 1 — Agent-initiated interrupt (`expected_interrupt` is set):**
+
+If the eval has an `expected_interrupt` field, read `RUN_DIR/transcript_N.txt` and judge
+whether the agent's final message matches the described interrupt — i.e. the agent paused
+mid-task to ask the user a clarifying question or request input instead of proceeding
+autonomously. If it matches, auto-resume without human input by sending `next_turn_instruction`
+back to the session:
+
+```bash
+claude --resume SESSION_ID \
+  --dangerously-skip-permissions --verbose --output-format stream-json \
+  --max-turns MAX_TURNS -p "NEXT_TURN_INSTRUCTION" > RUN_DIR/raw_N_t2.jsonl 2>&1
+```
+
+Parse the continuation with the same parse script (substitute `raw_N_t2.jsonl` and
+`meta_N_t2.txt`) and append to `RUN_DIR/transcript_N.txt`. Update `RATE_LIMITED` from
+`meta_N_t2.txt`. Then continue to step e for grading — do not prompt the human unless
+`WAITING_URL` is non-empty in the resumed turn.
+
+**Case 2 — Browser auth flow (`WAITING_URL` is non-empty):**
+
+If `WAITING_URL` is non-empty, the agent started an auth flow and is
+suspended at its session boundary. Wait 5 seconds, then check whether
+the auth flow completed automatically:
+
+```bash
+sleep 5 && uv run authsome list
+```
+
+If the relevant provider now shows `connected`, proceed directly to resuming
+the session (skip the user prompt). If it is still `not_connected`, show the user:
+
+> The agent is waiting. Please complete the auth flow at: `WAITING_URL`
+> Tell me "done" when finished.
+
+Wait for the user to reply "done". Then resume the claude session and
+append the continuation to the transcript:
+
+```bash
+claude --resume SESSION_ID \
+  --dangerously-skip-permissions --verbose --output-format stream-json \
+  --max-turns MAX_TURNS -p "done" > RUN_DIR/raw_N_t2.jsonl 2>&1
+```
+
+Parse turn 2 with the same script above (substitute `raw_N_t2.jsonl` and
+`meta_N_t2.txt`), then append its transcript to `RUN_DIR/transcript_N.txt`:
+
+```bash
+uv run python - RUN_DIR/raw_N_t2.jsonl >> RUN_DIR/transcript_N.txt 2> RUN_DIR/meta_N_t2.txt <<'PYEOF'
+# ... same parse script as above ...
+PYEOF
+
+# Update RATE_LIMITED if turn 2 was rate-limited
+RATE_LIMITED_T2=$(grep "^RATE_LIMITED=" RUN_DIR/meta_N_t2.txt | cut -d= -f2)
+[ "$RATE_LIMITED_T2" = "true" ] && RATE_LIMITED=true
+```
+
+If `WAITING_URL` is empty and no agent-initiated interrupt was detected for a `requires_human`
+eval, the agent finished in one turn (e.g. it polled for completion itself) — no resume needed.
+
+#### e. Grade the transcript
+
+Call claude as the LLM judge with the full eval criteria and the transcript:
+
+```bash
+uv run python - RUN_DIR/transcript_N.txt EVAL_ID <<'PYEOF' > RUN_DIR/verdict_N.json
+import sys, json, subprocess
+from pathlib import Path
+
+transcript = Path(sys.argv[1]).read_text()
+eval_id = int(sys.argv[2])
+evals = json.loads(Path("evals/evals.json").read_text())["evals"]
+eval_ = next(e for e in evals if e["id"] == eval_id)
+
+JUDGE_PROMPT = """\
+You are an eval grader for an agent called Authsome. You receive:
+- An agent transcript (stdout+stderr from a live agent run)
+- Environment pre-conditions describing the starting state
+- An outcome criterion (did the task succeed?)
+- An optional trajectory_efficiency criterion (did the agent take the right number of meaningful steps?)
+
+Return a JSON object with this exact structure:
+{
+  "outcome": {"passed": true, "evidence": "one sentence quoting or describing transcript evidence"},
+  "trajectory_efficiency": {"passed": true, "evidence": "one sentence quoting or describing transcript evidence"}
+}
+
+Rules:
+- Grade outcome and trajectory_efficiency independently.
+- When counting meaningful steps for trajectory_efficiency, **ignore scaffolding steps**:
+  skill loading or calling skill tool, using one extra step to parse and format a
+  response, returning results to the user, reading --help, version checks, and similar
+  overhead. Only task-relevant actions count (API calls, auth flows, etc).
+- The actual number of LLM calls will be higher than the expected step count — this is normal.
+- If trajectory_efficiency criterion is absent, return {"passed": null, "evidence": "not evaluated"} for it.
+- Be strict: burden of proof to pass is on the transcript.
+- evidence must quote or specifically reference the transcript, not repeat the criterion.\
+"""
+
+prompt = f"""{JUDGE_PROMPT}
+
+Environment: {eval_["environment"]}
+
+Outcome criterion: {eval_["outcome"]}
+
+Trajectory efficiency criterion: {eval_.get("trajectory_efficiency", "(not provided — skip this grade)")}
+
+Full transcript:
+---
+{transcript}
+---
+
+Return ONLY valid JSON, no markdown fences."""
+
+result = subprocess.run(
+    ["claude", "-p", prompt, "--output-format", "text"],
+    capture_output=True, text=True, timeout=120,
+)
+
+if result.returncode != 0:
+    raise RuntimeError(f"claude judge failed (exit {result.returncode}): {result.stderr[:300]}")
+
+raw = result.stdout.strip()
+if "```" in raw:
+    for part in raw.split("```"):
+        part = part.strip().lstrip("json").strip()
+        if part.startswith("{"):
+            raw = part
+            break
+
+verdict = json.loads(raw)
+if "trajectory_efficiency" not in eval_:
+    verdict["trajectory_efficiency"] = {"passed": None, "evidence": "not evaluated"}
+
+print(json.dumps(verdict, indent=2))
+PYEOF
+```
+
+Read `RUN_DIR/verdict_N.json` and print the result line:
+
+```
+[result] outcome=✓/✗  trajectory=✓/✗/—
+         outcome  : <evidence>
+         trajectory: <evidence>
+```
+
+#### f. Append result to grading.json
+
+```bash
+uv run python - RUN_DIR/grading.json EVAL_ID "$RATE_LIMITED" <<'PYEOF'
+import sys, json
+from datetime import datetime
+from pathlib import Path
+
+grading_path = Path(sys.argv[1])
+eval_id = int(sys.argv[2])
+rate_limited = sys.argv[3] == "true"
+
+evals = json.loads(Path("evals/evals.json").read_text())["evals"]
+eval_ = next(e for e in evals if e["id"] == eval_id)
+
+run_dir = grading_path.parent
+verdict = json.loads((run_dir / f"verdict_{eval_id}.json").read_text())
+authsome_state = (run_dir / f"authsome_state_{eval_id}.txt").read_text() \
+    if (run_dir / f"authsome_state_{eval_id}.txt").exists() else ""
+
+result_entry = {
+    "id": eval_id,
+    "name": eval_.get("name", ""),
+    "prompt": eval_["prompt"],
+    "agent": eval_.get("agent", "claude"),
+    "environment": eval_["environment"],
+    "authsome_state": authsome_state,
+    "requires_human": eval_.get("requires_human", False),
+    "rate_limited": rate_limited,
+    **verdict,
+}
+
+existing = {"results": []}
+if grading_path.exists():
+    existing = json.loads(grading_path.read_text())
+
+all_results = existing["results"] + [result_entry]
+passed  = sum(1 for r in all_results if r["outcome"]["passed"] is True)
+failed  = sum(1 for r in all_results if r["outcome"]["passed"] is False)
+skipped = sum(1 for r in all_results if r["outcome"]["passed"] is None)
+
+grading = {
+    "skill_name": "authsome",
+    "timestamp": datetime.now().isoformat(timespec="seconds"),
+    "summary": {"passed": passed, "failed": failed, "skipped": skipped, "total": len(all_results)},
+    "results": all_results,
+}
+grading_path.write_text(json.dumps(grading, indent=2))
+
+summary = grading["summary"]
+print(f"Done: {summary['passed']} passed / {summary['failed']} failed / {summary['skipped']} skipped out of {summary['total']}")
+print(f"Results: {grading_path}")
+PYEOF
+```
+
+Before running the save script, write the current authsome state to
+`RUN_DIR/authsome_state_N.txt` so it's captured in the grading record:
+
+```bash
+uv run authsome list > RUN_DIR/authsome_state_N.txt 2>&1
+```
+
+#### g. State-check and continue
+
+After showing the verdict, immediately prepare for the next eval:
+
+1. Run `uv run authsome list` and compare against the next eval's `environment` field.
+2. Fix any mismatches inline (e.g. `uv run authsome revoke github`). Re-check until state matches.
+3. If you need to login (e.g. for provider X) and the environment says provider X is NOT connected, it is okay to use `uv run authsome login <provider>` and `uv run authsome list` to poll the status of the provider a few seconds later to see if the login was successful.
+4. Only pause and ask the user when:
+   - If polling fails during login (show the URL, wait for "done")
+   - A `requires_human` eval where the user must act during the run
+
+---
+
+### 3. Teardown
+
+Delete the eval profile's key files:
+
+```bash
+rm ~/.authsome/client/identities/EVAL_HANDLE.json
+rm ~/.authsome/client/identities/EVAL_HANDLE.key
+```
+
+Then switch back to the user's original profile:
+
+```bash
+uv run authsome profile use <original-handle>
+```
+
+---
+
+### 4. Generate report
+
+```bash
+uv run python evals/generate_report.py RUN_DIR/grading.json
+```
+
+Tell the user the report path. The script opens it automatically.

{authsome-0.3.0 → authsome-0.3.2}/.claude-plugin/marketplace.json

@@ -18,7 +18,7 @@
         "name": "Agentr",
         "url": "https://github.com/agentrhq"
       },
-      "homepage": "https://authsome.agentr.dev",
+      "homepage": "https://authsome.ai",
       "license": "MIT",
       "keywords": ["auth", "oauth2", "credentials", "agent-identity", "broker"],
       "category": "auth"

authsome-0.3.2/.github/release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.3.2"
+}

{authsome-0.3.0 → authsome-0.3.2}/.gitignore

@@ -244,5 +244,12 @@ __marimo__/
 # Git worktrees
 .worktrees/
 .claude/worktrees/
+
 # Local authsome home directory
 .authsome/
+
+# Superpowers agent docs (local planning artifacts)
+docs/superpowers/
+
+# Authsome skill (generated at eval time)
+.claude/skills/authsome/

{authsome-0.3.0 → authsome-0.3.2}/CHANGELOG.md

@@ -1,5 +1,67 @@
 # Changelog
 
+## [0.3.2](https://github.com/agentrhq/authsome/compare/authsome-v0.3.1...authsome-v0.3.2) (2026-05-20)
+
+
+### Features
+
+* Add posthog telemetry events ([575a464](https://github.com/agentrhq/authsome/commit/575a4648fbfa8c4de7b46c50311c2b426587977c))
+* Add posthog telemetry events ([8797a94](https://github.com/agentrhq/authsome/commit/8797a94b406fe109b0a2216d693b74dd17446892))
+* **evals:** /run-evals command + profile/run-dir flags ([bdeae58](https://github.com/agentrhq/authsome/commit/bdeae583a2d5bd9b4a28e1b717c74240469c890a))
+* **evals:** add expected_interrupt and next_turn_instruction eval fields ([c4b2a93](https://github.com/agentrhq/authsome/commit/c4b2a9304ab53773c4b76cd4245b5663e744e4fc))
+* **evals:** capture real claude transcripts via stream-json subprocess ([1b28f5a](https://github.com/agentrhq/authsome/commit/1b28f5ab4f9cd702e2ccf8b2bf805b0a58418158))
+* **evals:** move new evals schema to evals/evals.json, restore skills copy ([5bb73ba](https://github.com/agentrhq/authsome/commit/5bb73ba509dc3a1b5d55c1356210f724d7c4b130))
+* **evals:** profile isolation + authsome state check per eval ([73d3e70](https://github.com/agentrhq/authsome/commit/73d3e70b18387ec5510714e3ef4254f8fb33c49e))
+* **proxy:** configurable intercept scope and unmatched policy ([987e312](https://github.com/agentrhq/authsome/commit/987e312aeeb680a4910697a18abb6eadb62d2b95))
+* update health check to validate connections based on active identity and add test coverage ([9290169](https://github.com/agentrhq/authsome/commit/929016909595a68c4452c2291564241277df5ec6))
+* update health check to validate connections based on active identity and add test coverage ([3fa9f97](https://github.com/agentrhq/authsome/commit/3fa9f97c8b3236b57649ae8b8a8e5ec538da8ca2))
+
+
+### Bug Fixes
+
+* copy full skill folder in evals and fix login flow links in authsome skill ([e8918a9](https://github.com/agentrhq/authsome/commit/e8918a97369f483f12b66e34d2eac5156ebc51f2))
+* **evals:** use claude --system-prompt for judge, grade on rate limit ([b790c63](https://github.com/agentrhq/authsome/commit/b790c6329890cc0ccc824b51ca8b428ad6bca1c6))
+* **evals:** use hermes as LLM judge instead of claude -p ([1157837](https://github.com/agentrhq/authsome/commit/1157837e4bda094d3f8f804886ecc4820fa62a5c))
+* **marketplace:** point plugin homepage to authsome.ai ([11ffd80](https://github.com/agentrhq/authsome/commit/11ffd80da7e0c05c998236bfa3a7a9c59fb17de1))
+* **marketplace:** point plugin homepage to authsome.ai ([a767cbc](https://github.com/agentrhq/authsome/commit/a767cbcea2464ed8fc7469219d33df3c5df9d794))
+* **proxy:** address PR review feedback on mode validation and route defaults ([83ab469](https://github.com/agentrhq/authsome/commit/83ab4691e63ff62c8db9168af4e2cbbfdba55401))
+
+
+### Documentation
+
+* add GitHub OAuth app setup walkthrough to quickstart ([f45d9c9](https://github.com/agentrhq/authsome/commit/f45d9c9ece6bb7ba017b6ad6c1041b3bac53a4f7))
+* add Roadmap, Contributing, and Links sections to README ([07534a4](https://github.com/agentrhq/authsome/commit/07534a4cdcec7f05f552b49f5d8d5a032232a630))
+* add Roadmap, Contributing, and Links sections; rewrite roadmap.mdx ([03990b2](https://github.com/agentrhq/authsome/commit/03990b28db0460ea18c5c16eea7848ab262d235d))
+* correct roadmap against changelog as source of truth ([eec08e3](https://github.com/agentrhq/authsome/commit/eec08e3b1605ac542153481b6faf49ab0a904676))
+* **evals:** add hermes smoke test to pre-session setup ([bc4ef39](https://github.com/agentrhq/authsome/commit/bc4ef3917d74747fbeddec3c0f540f28b9f895d7))
+* **evals:** add skip handling and per-eval max_turns config ([68ae0ed](https://github.com/agentrhq/authsome/commit/68ae0ed68b49df4d45083a911d8482dece1ae7a3))
+* **evals:** merge setup.md into run-evals command, delete setup.md ([072836f](https://github.com/agentrhq/authsome/commit/072836f2d8a95822023f6f6f428d00bc21430875))
+* **evals:** remove profile creation from run-evals command ([33ab525](https://github.com/agentrhq/authsome/commit/33ab5258b8b7144c02d12c5d3b71fa0aba4fa707))
+* **evals:** update design spec and plan to reflect as-built state ([2558f5c](https://github.com/agentrhq/authsome/commit/2558f5c0de134bc26fee4d59a2c1120b736563c9))
+* mark policy layer and firewall rules as shipped, add multi-user to coming next ([b1487e8](https://github.com/agentrhq/authsome/commit/b1487e87bcf5c99912181331296441190c4c2f05))
+* **quickstart:** add provider tabs and a runnable agent example ([7c577ab](https://github.com/agentrhq/authsome/commit/7c577abe64fb9b4db34fa8b0bbc43f72289dd8da))
+* **quickstart:** GitHub OAuth setup walkthrough and provider tabs ([63ffdec](https://github.com/agentrhq/authsome/commit/63ffdec8abe91c90966bfb61b8b547903b945bcf))
+* reframe roadmap as end-user capabilities, not implementation work ([0740764](https://github.com/agentrhq/authsome/commit/07407646f6c88c8c1b72d8a43f947f80e24492dd))
+* rewrite profile storage model to match current architecture ([457d1b2](https://github.com/agentrhq/authsome/commit/457d1b2ee7d54ce03ea697beb4913a5ce01ce0c7))
+* rewrite profile storage model to match current architecture ([773323a](https://github.com/agentrhq/authsome/commit/773323ab73bd8a05e251f5ef121b2b072dc3259a))
+* rewrite roadmap.mdx, remove ROADMAP.md, link README to docs ([a165d37](https://github.com/agentrhq/authsome/commit/a165d372fc5b44d7ee34066e40d6ade24b9ed575))
+* simplify hosted daemon mode description in roadmap ([5458bf6](https://github.com/agentrhq/authsome/commit/5458bf62a5ededf7cfa2030d104bcf94b41178e6))
+* **site:** adopt skill-driven CLI conventions across the docs ([8ba6967](https://github.com/agentrhq/authsome/commit/8ba6967f490502ab55bd401de25e8328bf476067))
+* **site:** adopt skill-driven CLI conventions across the docs ([71b89fd](https://github.com/agentrhq/authsome/commit/71b89fd036dac67c7cfc761295b39889bf3ec9f2))
+
+## [0.3.1](https://github.com/agentrhq/authsome/compare/authsome-v0.3.0...authsome-v0.3.1) (2026-05-17)
+
+
+### Bug Fixes
+
+* **cli:** resolve three CLI bugs and improve audit log command ([3b990e3](https://github.com/agentrhq/authsome/commit/3b990e3cae998d9ccaccb421b5cb577c2bb89de3))
+* **cli:** resolve three CLI bugs, improve audit log, and sync docs ([dd9cad3](https://github.com/agentrhq/authsome/commit/dd9cad326cb2817826eb8e5b8bb42f5f3df8e2a2))
+
+
+### Documentation
+
+* **cli:** sync reference and manual-testing guide with 0.3.0 implementation ([bdf659f](https://github.com/agentrhq/authsome/commit/bdf659ffffc0a0c2100cc21508daec042161656e))
+
 ## [0.3.0](https://github.com/agentrhq/authsome/compare/authsome-v0.2.4...authsome-v0.3.0) (2026-05-15)
 
 

{authsome-0.3.0 → authsome-0.3.2}/CONTRIBUTING.md

@@ -86,7 +86,7 @@ The diff shows what changed. The commit message should say why. Future readers (
 ## Getting started
 
 ```bash
-git clone https://github.com/manojbajaj95/authsome.git
+git clone https://github.com/agentrhq/authsome.git
 cd authsome
 uv pip install -e ".[dev]"
 pre-commit install          # runs ruff automatically on every commit