arm101-cli 0.6.0__tar.gz → 0.7.0__tar.gz

arm101_cli-0.7.0/.devague/current

@@ -0,0 +1 @@
+arm101-s-gated-write-hardware-verbs-set-motor-id-c

arm101_cli-0.7.0/.devague/current_plan

@@ -0,0 +1 @@
+arm101-s-gated-write-hardware-verbs-set-motor-id-c

arm101_cli-0.7.0/.devague/frames/arm101-s-gated-write-hardware-verbs-set-motor-id-c.json

@@ -0,0 +1,294 @@
+{
+  "slug": "arm101-s-gated-write-hardware-verbs-set-motor-id-c",
+  "title": "arm101's gated-write hardware verbs (set-motor-id, center-motor) now resolve consent in three driver modes \u2014 human-interactive (type yes at a TTY), agent-interactive (an AI reads a structured write-plan and consents explicitly), and non-interactive (scripted) \u2014 so an AI agent can safely drive an EEPROM write or a commanded motion without faking a TTY, while the unconsented non-TTY default still refuses.",
+  "schema_version": 1,
+  "status": "exported",
+  "created": "2026-06-27T10:35:04Z",
+  "updated": "2026-06-27T11:06:51Z",
+  "claims": [
+    {
+      "id": "c1",
+      "kind": "announcement",
+      "text": "arm101's gated-write hardware verbs (set-motor-id, center-motor) now resolve consent in three driver modes \u2014 human-interactive (type yes at a TTY), agent-interactive (an AI reads a structured write-plan and consents explicitly), and non-interactive (scripted) \u2014 so an AI agent can safely drive an EEPROM write or a commanded motion without faking a TTY, while the unconsented non-TTY default still refuses.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h4",
+          "text": "Each of the three modes is pinned by a test: TTY->interactive prompt; non-TTY+consent->execute (1-step --apply for set-motor-id, 2-step --apply --plan-hash for center-motor); non-TTY+no-consent->refuse (exit 2).",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c2",
+      "kind": "audience",
+      "text": "Three operator types of the SO-101 pre-assembly flow: a human at a bench terminal, an AI agent (Claude Code) driving the arm101 CLI, and scripted/CI callers with no one present.",
+      "origin": "llm",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h7",
+          "text": "All three operator types exercise the SAME verbs through one resolver \u2014 a test demonstrates a human-TTY prompt path, an agent --apply path, and a non-TTY no-consent refusal.",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c3",
+      "kind": "after_state",
+      "text": "Every gated side-effect verb resolves consent through ONE shared mode-aware helper; an agent can drive set-motor-id/center-motor to completion with explicit consent and machine-readable I/O; a human still types yes at a TTY; a bare non-TTY run with no consent flag still refuses (exit 2).",
+      "origin": "llm",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h8",
+          "text": "After the change neither verb has its own duplicated gate \u2014 both import resolve_consent from arm101/cli/_consent.py (asserted by an import/grep test); the human path is behaviorally unchanged.",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c4",
+      "kind": "before_state",
+      "text": "set-motor-id/center-motor call _require_tty() and HARD-refuse any non-TTY stdin (exit 2). The only consent channel is a human typing yes at a TTY, so the agent operator can never drive the write \u2014 forcing PTY-faking hacks that defeat the very gate they bypass.",
+      "origin": "llm",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h9",
+          "text": "The CURRENT code is accurately described: set_motor_id._require_tty and center_motor._require_tty both raise exit 2 on non-TTY today (the pre-change tests we are replacing assert exactly this).",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c5",
+      "kind": "why_it_matters",
+      "text": "Here the operator IS an agent. A guard that blocks all non-TTY input also blocks the legitimate operator. A mode-aware consent model makes the agent a first-class, attributable driver without weakening the human safety gate.",
+      "origin": "llm",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h10",
+          "text": "The agent operator genuinely has no TTY \u2014 proven live: invoking 'arm101 set-motor-id 1 < /dev/null' today returns exit 2 at the TTY guard.",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c6",
+      "kind": "boundary",
+      "text": "NOT building colleague's full ANSI cockpit / redraw TUI / per-keystroke reader. Scope is the consent + mode-resolution contract for gated hardware verbs plus a dry-run/plan view \u2014 not a general UI framework. Read-only verbs (calibrate-motor, detection) are unchanged.",
+      "origin": "llm",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h11",
+          "text": "No ANSI/curses/redraw/per-keystroke code is added \u2014 the diff touches only consent resolution, plan files, audit, and the two verbs (verifiable by reviewing changed files).",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c7",
+      "kind": "success_signal",
+      "text": "An agent runs set-motor-id end-to-end on F1 with explicit consent and no PTY hack; a human terminal run is unchanged; a bare non-TTY no-flag run still exits refusing; set-motor-id AND center-motor both route through the one shared consent helper.",
+      "origin": "llm",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h12",
+          "text": "On F1 an agent completes 'set-motor-id <id> --apply' with no PTY hack; the existing human-TTY tests still pass; a bare non-TTY no-flag run still exits 2; grep shows BOTH verbs call resolve_consent.",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c8",
+      "kind": "decision",
+      "text": "Consent resolves via ONE shared strategy mirroring colleague's _resolve_decide: (a) explicit consent flag present -> consent granted WITHOUT a TTY; (b) else stdin is a TTY -> interactive prompt the human types yes; (c) else refuse with a hint. The bare no-flag + no-TTY path still refuses (exit 2) \u2014 we ADD the explicit-flag channel, we don't remove the default-refuse.",
+      "origin": "llm",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h1",
+          "text": "A bare 'set-motor-id 1' with no TTY and no consent flag still exits 2 (default-refuse preserved) \u2014 pinned by a test.",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c9",
+      "kind": "requirement",
+      "text": "A --dry-run/plan mode (valid in all three modes) runs detection + read-only snapshot and emits the full write-plan (port, from_id->to_id, baud / target position, action-kind label) as text or JSON, then exits 0 with ZERO side effects. This is the 'agent reads exactly what will happen before consenting' primitive \u2014 the machine-readable mirror.",
+      "origin": "llm",
+      "status": "rejected",
+      "honesty_conditions": [
+        {
+          "id": "h2",
+          "text": "--dry-run calls NO bus write/motion: a FakeBus test asserts write_id_baudrate / write_goal_position is never invoked under --dry-run.",
+          "status": "proposed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c10",
+      "kind": "requirement",
+      "text": "set-motor-id and center-motor both route their gate through ONE shared consent helper (e.g. arm101/cli/_consent.py: resolve_consent(args, plan) -> bool|raise). No verb-specific consent logic; the verbs differ only in the plan object they pass in.",
+      "origin": "llm",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h3",
+          "text": "The shared helper carries no per-verb branching: set-motor-id and center-motor pass different plan objects but call the identical resolve_consent().",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c11",
+      "kind": "decision",
+      "text": "Headless consent requires the SPECIFIC target named on the command line (e.g. 'set-motor-id 6 --apply' consents to id 6); a bare consent flag with no target is refused. [resolves v2]",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c12",
+      "kind": "decision",
+      "text": "Commanded MOTION is gated HARDER than an EEPROM write: motion refuses the pure-CI tier \u2014 it needs a human at a TTY OR a present agent that verifies via the 2-step plan-file read; an EEPROM write is allowed headless with consent. [resolves v1]",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c13",
+      "kind": "decision",
+      "text": "The consent/execute flag is --apply (NOT --yes). Default output is MARKDOWN (the agent-readable format); --json is for APPLICATION consumers, not agents. 'Agents verify' via --apply.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c14",
+      "kind": "decision",
+      "text": "Risky actions use a 2-STEP FILE HANDSHAKE, not a single flag: (1) the command writes a plan FILE describing exactly what will happen; (2) the agent must READ that plan file (direct file read) and only then run --apply. The handshake forces the agent to consume the plan before executing.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [],
+      "hard_questions": [
+        {
+          "id": "q1",
+          "text": "risk: Stale-state race: motor state can change between plan generation and --apply. Mitigation: plan embeds a state snapshot + timestamp + hash; --apply re-checks and refuses if stale/mismatched.",
+          "resolved": false,
+          "blocking": false
+        }
+      ],
+      "links": []
+    },
+    {
+      "id": "c15",
+      "kind": "decision",
+      "text": "Headless writes require an attributed operator identity (ARM101_OPERATOR env \u2192 culture.yaml nick \u2192 tty:$USER); a non-TTY write is REFUSED without an identity; identity recorded in the result + an append-only audit log. [resolves v3]",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [],
+      "hard_questions": [
+        {
+          "id": "q2",
+          "text": "risk: Identity env vars (ARM101_OPERATOR) are trivially spoofable \u2014 treat attribution as informational audit, never as authorization.",
+          "resolved": false,
+          "blocking": false
+        }
+      ],
+      "links": []
+    },
+    {
+      "id": "c16",
+      "kind": "decision",
+      "text": "Interaction mode is AUTO-DETECTED from (TTY?, output format, consent state); no explicit --mode flag. [resolves v4]",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c17",
+      "kind": "requirement",
+      "text": "The plan file carries a plan-HASH; --apply must reference a matching hash, enforcing 'read the plan before applying' and rejecting a stale/mismatched plan. (mechanism for the 2-step handshake)",
+      "origin": "llm",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h5",
+          "text": "An --apply with a mismatched or stale plan-hash is refused (exit 2) and performs NO write \u2014 pinned by a test that mutates motor state between plan and apply.",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c18",
+      "kind": "decision",
+      "text": "TIERED consent weight: set-motor-id (reversible EEPROM) uses 1-step agent consent \u2014 'set-motor-id <id> --apply' (specific target + flag, attributed + audited, no plan file). center-motor (physical motion / damage risk) requires the full 2-step plan-file handshake (dry-run writes JSON plan file \u2192 agent must Read it \u2192 '--apply --plan-hash <hash>'). Honors 'motion stricter than EEPROM'.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c19",
+      "kind": "requirement",
+      "text": "Headless callers get a ZERO-side-effect plan FIRST: set-motor-id prints a markdown plan to stdout; center-motor writes a JSON plan FILE (~/.arm101/plans/...) with the plan-hash INSIDE the file only (never stdout) plus a markdown pointer. The plan/dry-run path performs no bus write and no motion.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h6",
+          "text": "A FakeBus test asserts the plan/dry-run path calls zero bus writes and zero motion (write_id_baudrate / enable_torque / write_goal_position never invoked).",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    }
+  ],
+  "open_vagueness": [
+    {
+      "id": "v1",
+      "text": "Full EEPROM Lock-register unlock/relock inside write_id_baudrate (STS3215 addr 55) is DEFERRED to a follow-on PR. This spec only SURFACES lock_register in the plan snapshot and warns when Lock=1 (a locked motor silently discards the write while the SDK returns result=0,error=0).",
+      "kind": "follow_up",
+      "claim_id": null
+    }
+  ]
+}

arm101_cli-0.7.0/.devague/plans/arm101-s-gated-write-hardware-verbs-set-motor-id-c.json

@@ -0,0 +1,250 @@
+{
+  "slug": "arm101-s-gated-write-hardware-verbs-set-motor-id-c",
+  "title": "arm101's gated-write hardware verbs (set-motor-id, center-motor) now resolve consent in three driver modes \u2014 human-interactive (type yes at a TTY), agent-interactive (an AI reads a structured write-plan and consents explicitly), and non-interactive (scripted) \u2014 so an AI agent can safely drive an EEPROM write or a commanded motion without faking a TTY, while the unconsented non-TTY default still refuses.",
+  "frame_slug": "arm101-s-gated-write-hardware-verbs-set-motor-id-c",
+  "schema_version": 1,
+  "status": "exported",
+  "created": "2026-06-27T11:25:38Z",
+  "updated": "2026-06-27T11:31:08Z",
+  "targets": [
+    {
+      "id": "c1",
+      "kind": "announcement",
+      "text": "arm101's gated-write hardware verbs (set-motor-id, center-motor) now resolve consent in three driver modes \u2014 human-interactive (type yes at a TTY), agent-interactive (an AI reads a structured write-plan and consents explicitly), and non-interactive (scripted) \u2014 so an AI agent can safely drive an EEPROM write or a commanded motion without faking a TTY, while the unconsented non-TTY default still refuses."
+    },
+    {
+      "id": "h4",
+      "kind": "honesty",
+      "text": "Each of the three modes is pinned by a test: TTY->interactive prompt; non-TTY+consent->execute (1-step --apply for set-motor-id, 2-step --apply --plan-hash for center-motor); non-TTY+no-consent->refuse (exit 2)."
+    },
+    {
+      "id": "c2",
+      "kind": "audience",
+      "text": "Three operator types of the SO-101 pre-assembly flow: a human at a bench terminal, an AI agent (Claude Code) driving the arm101 CLI, and scripted/CI callers with no one present."
+    },
+    {
+      "id": "h7",
+      "kind": "honesty",
+      "text": "All three operator types exercise the SAME verbs through one resolver \u2014 a test demonstrates a human-TTY prompt path, an agent --apply path, and a non-TTY no-consent refusal."
+    },
+    {
+      "id": "c3",
+      "kind": "after_state",
+      "text": "Every gated side-effect verb resolves consent through ONE shared mode-aware helper; an agent can drive set-motor-id/center-motor to completion with explicit consent and machine-readable I/O; a human still types yes at a TTY; a bare non-TTY run with no consent flag still refuses (exit 2)."
+    },
+    {
+      "id": "h8",
+      "kind": "honesty",
+      "text": "After the change neither verb has its own duplicated gate \u2014 both import resolve_consent from arm101/cli/_consent.py (asserted by an import/grep test); the human path is behaviorally unchanged."
+    },
+    {
+      "id": "c4",
+      "kind": "before_state",
+      "text": "set-motor-id/center-motor call _require_tty() and HARD-refuse any non-TTY stdin (exit 2). The only consent channel is a human typing yes at a TTY, so the agent operator can never drive the write \u2014 forcing PTY-faking hacks that defeat the very gate they bypass."
+    },
+    {
+      "id": "h9",
+      "kind": "honesty",
+      "text": "The CURRENT code is accurately described: set_motor_id._require_tty and center_motor._require_tty both raise exit 2 on non-TTY today (the pre-change tests we are replacing assert exactly this)."
+    },
+    {
+      "id": "c5",
+      "kind": "why_it_matters",
+      "text": "Here the operator IS an agent. A guard that blocks all non-TTY input also blocks the legitimate operator. A mode-aware consent model makes the agent a first-class, attributable driver without weakening the human safety gate."
+    },
+    {
+      "id": "h10",
+      "kind": "honesty",
+      "text": "The agent operator genuinely has no TTY \u2014 proven live: invoking 'arm101 set-motor-id 1 < /dev/null' today returns exit 2 at the TTY guard."
+    },
+    {
+      "id": "c6",
+      "kind": "boundary",
+      "text": "NOT building colleague's full ANSI cockpit / redraw TUI / per-keystroke reader. Scope is the consent + mode-resolution contract for gated hardware verbs plus a dry-run/plan view \u2014 not a general UI framework. Read-only verbs (calibrate-motor, detection) are unchanged."
+    },
+    {
+      "id": "h11",
+      "kind": "honesty",
+      "text": "No ANSI/curses/redraw/per-keystroke code is added \u2014 the diff touches only consent resolution, plan files, audit, and the two verbs (verifiable by reviewing changed files)."
+    },
+    {
+      "id": "c7",
+      "kind": "success_signal",
+      "text": "An agent runs set-motor-id end-to-end on F1 with explicit consent and no PTY hack; a human terminal run is unchanged; a bare non-TTY no-flag run still exits refusing; set-motor-id AND center-motor both route through the one shared consent helper."
+    },
+    {
+      "id": "h12",
+      "kind": "honesty",
+      "text": "On F1 an agent completes 'set-motor-id <id> --apply' with no PTY hack; the existing human-TTY tests still pass; a bare non-TTY no-flag run still exits 2; grep shows BOTH verbs call resolve_consent."
+    },
+    {
+      "id": "c10",
+      "kind": "requirement",
+      "text": "set-motor-id and center-motor both route their gate through ONE shared consent helper (e.g. arm101/cli/_consent.py: resolve_consent(args, plan) -> bool|raise). No verb-specific consent logic; the verbs differ only in the plan object they pass in."
+    },
+    {
+      "id": "h3",
+      "kind": "honesty",
+      "text": "The shared helper carries no per-verb branching: set-motor-id and center-motor pass different plan objects but call the identical resolve_consent()."
+    },
+    {
+      "id": "c17",
+      "kind": "requirement",
+      "text": "The plan file carries a plan-HASH; --apply must reference a matching hash, enforcing 'read the plan before applying' and rejecting a stale/mismatched plan. (mechanism for the 2-step handshake)"
+    },
+    {
+      "id": "h5",
+      "kind": "honesty",
+      "text": "An --apply with a mismatched or stale plan-hash is refused (exit 2) and performs NO write \u2014 pinned by a test that mutates motor state between plan and apply."
+    },
+    {
+      "id": "c19",
+      "kind": "requirement",
+      "text": "Headless callers get a ZERO-side-effect plan FIRST: set-motor-id prints a markdown plan to stdout; center-motor writes a JSON plan FILE (~/.arm101/plans/...) with the plan-hash INSIDE the file only (never stdout) plus a markdown pointer. The plan/dry-run path performs no bus write and no motion."
+    },
+    {
+      "id": "h6",
+      "kind": "honesty",
+      "text": "A FakeBus test asserts the plan/dry-run path calls zero bus writes and zero motion (write_id_baudrate / enable_torque / write_goal_position never invoked)."
+    }
+  ],
+  "tasks": [
+    {
+      "id": "t1",
+      "summary": "bus: add FeetechBus.read_lock() + FakeBus lock_register snapshot field",
+      "origin": "llm",
+      "status": "confirmed",
+      "acceptance_criteria": [
+        "FeetechBus.read_lock(motor_id) reads STS3215 register 55 (1 byte) and returns 0/1; unit test asserts it reads addr 55 via the fake packet handler.",
+        "FakeBus.read_info() includes a constructor-settable 'lock_register' key (default 0) so plan snapshots carry it; test asserts the key is present.",
+        "No behavior change to existing bus methods; existing tests/test_bus.py still pass."
+      ],
+      "deps": [],
+      "covers": []
+    },
+    {
+      "id": "t2",
+      "summary": "consent core: new arm101/cli/_consent.py (resolve_consent + plan build/write/verify + audit + operator identity)",
+      "origin": "llm",
+      "status": "confirmed",
+      "acceptance_criteria": [
+        "resolve_consent(args,*,verb,require_plan_hash) -> 'interactive' under a TTY; 'dry_run' when non-TTY and not args.apply; 'agent' when non-TTY+args.apply and (require_plan_hash False OR plan_hash is valid sha256:<64hex>); raises CliError(EXIT_ENV_ERROR) when non-TTY+apply and require_plan_hash but hash missing; CliError(EXIT_USER_ERROR) when hash malformed. test_consent.py pins every row for both flag values.",
+        "build_plan(verb,port,info,action) returns schema_version/verb/created_at/port/operator/action/motor_snapshot(id,model,present_position,torque_enable,lock_register)/plan_hash; plan_hash = sha256 over canonical json of {verb,port,action,motor_snapshot(id,model,present_position,torque_enable)} (excludes operator/created_at/volatile sensors). Test: same state->same hash, changed present_position->different hash.",
+        "write_plan_file(plan) writes JSON to $ARM101_PLAN_DIR or ~/.arm101/plans/<verb>-<portbase>-<utc>.json and returns the path; emit_plan_stdout() writes MARKDOWN naming the path but NOT the hash. Test asserts hash is in the file and absent from stdout.",
+        "verify_plan_hash(supplied,verb,port,action,info) recomputes from live state; raises CliError(EXIT_ENV_ERROR) on mismatch, returns None on match. Test: mismatch->exit2, match->ok.",
+        "resolve_operator() = ARM101_OPERATOR else culture.yaml nick else 'tty:'+getuser(); write_audit(record) appends one JSONL line to $ARM101_AUDIT_LOG or ~/.arm101/audit.log and NEVER raises on write failure. Test asserts pending-before/success-after ordering and that an unwritable log path is swallowed.",
+        "Module introduces NO ANSI/curses/redraw code; uses _output.emit_* only."
+      ],
+      "deps": [
+        "t1"
+      ],
+      "covers": [
+        "c1",
+        "h4",
+        "c2",
+        "h7",
+        "c3",
+        "c5",
+        "c10",
+        "h3",
+        "c17",
+        "h5",
+        "c19",
+        "h6"
+      ]
+    },
+    {
+      "id": "t3",
+      "summary": "set-motor-id: tiered 1-step --apply via resolve_consent(require_plan_hash=False); drop _require_tty/_confirm",
+      "origin": "llm",
+      "status": "confirmed",
+      "acceptance_criteria": [
+        "set_motor_id imports resolve_consent and no longer defines _require_tty or _confirm (grep test asserts absence); register() adds --apply (store_true) + --plan-hash with help noting --apply is non-TTY-only / ignored under a TTY.",
+        "Non-TTY + no --apply prints a markdown plan to stdout and performs ZERO eeprom writes (FakeBus.eeprom_writes == []).",
+        "Non-TTY + 'set-motor-id 6 --apply' (no hash needed, 1-step EEPROM tier) writes EEPROM exactly once after a 'pending' audit record; result names from_id->to_id, port, operator.",
+        "Non-TTY + --apply with new_id absent raises CliError(EXIT_USER_ERROR) and writes nothing (specific-target rule).",
+        "TTY path behaviorally unchanged: typed 'yes' writes, 'no'/EOF behave as today; the two old non-TTY-rejection tests are rewritten and result-text assertions updated for markdown."
+      ],
+      "deps": [
+        "t2"
+      ],
+      "covers": [
+        "c4",
+        "h9",
+        "c7",
+        "h12",
+        "h10",
+        "h8",
+        "c10",
+        "h3",
+        "c19",
+        "h6"
+      ]
+    },
+    {
+      "id": "t4",
+      "summary": "center-motor: 2-step plan-file handshake via resolve_consent(require_plan_hash=True); drop _require_tty/_confirm",
+      "origin": "llm",
+      "status": "confirmed",
+      "acceptance_criteria": [
+        "center_motor imports resolve_consent and no longer defines _require_tty/_confirm (grep test); register() adds --apply + --plan-hash.",
+        "Non-TTY + no --apply writes a JSON plan FILE (action carries workspace_warning; plan_hash in file) + markdown pointer to stdout; performs ZERO motion (FakeBus enable_torque/write_goal_position never called).",
+        "Non-TTY + --apply --plan-hash <matching> runs enable_torque->write_goal_position->relax (relax skipped with --keep-torque) after a 'pending' audit; <mismatched/stale> raises CliError(EXIT_ENV_ERROR) with no motion.",
+        "Non-TTY + --apply without --plan-hash raises CliError(EXIT_ENV_ERROR), no motion.",
+        "TTY path unchanged: workspace warning + typed 'yes' moves, 'no'/EOF aborts; existing tests pass after migration."
+      ],
+      "deps": [
+        "t2"
+      ],
+      "covers": [
+        "c4",
+        "h9",
+        "h8",
+        "c17",
+        "h5",
+        "c19",
+        "h6",
+        "c10"
+      ]
+    },
+    {
+      "id": "t5",
+      "summary": "docs lockstep: explain/catalog + overview + learn updated for --apply/--plan-hash and the three modes",
+      "origin": "llm",
+      "status": "confirmed",
+      "acceptance_criteria": [
+        "explain catalog gains entries for --apply/--plan-hash/dry-run-plan on set-motor-id and center-motor; test_every_catalog_path_resolves passes.",
+        "overview._VERBS descriptions and learn text mention agent mode / --apply; existing lockstep tests pass.",
+        "Docs/strings only \u2014 no ANSI/TUI code introduced."
+      ],
+      "deps": [
+        "t3",
+        "t4"
+      ],
+      "covers": [
+        "c6",
+        "h11"
+      ]
+    }
+  ],
+  "risks": [
+    {
+      "id": "r1",
+      "text": "Full EEPROM Lock-register unlock/relock inside write_id_baudrate deferred to a follow-on PR; this plan only surfaces lock_register + warns when Lock=1.",
+      "kind": "follow_up",
+      "task_id": null
+    },
+    {
+      "id": "r2",
+      "text": "Stale-plan TTL: hash-over-live-state catches state drift, but an idle motor with constant state means a hash never expires; a created_at TTL check is a soft (warn-only) mitigation.",
+      "kind": "unknown_nonblocking",
+      "task_id": null
+    },
+    {
+      "id": "r3",
+      "text": "Plan file is a TOCTOU surface; mitigated by computing the hash from live MOTOR state at apply time (not from file content), so file tampering can't authorize a different action.",
+      "kind": "unknown_nonblocking",
+      "task_id": null
+    }
+  ]
+}

{arm101_cli-0.6.0 → arm101_cli-0.7.0}/CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to this project will be documented in this file.
 Format follows [Keep a Changelog](https://keepachangelog.com/). This project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.7.0] - 2026-06-27
+
+### Added
+
+- Three-mode consent for the gated hardware verbs (set-motor-id, center-motor): a new shared arm101/cli/_consent.py core auto-detects the operator from (TTY?, --apply?, --plan-hash?) and resolves one of human-interactive (type `yes` at a TTY), agent-interactive (a non-TTY agent consents with --apply), or non-interactive dry-run (prints a read-only write-plan; zero side effects). An AI agent can now drive an EEPROM write / commanded motion without faking a TTY, while a human still gets the typed-confirmation gate.
+- Tiered consent matched to blast radius: set-motor-id (reversible EEPROM write) is 1-step (`set-motor-id <id> --apply`); center-motor (commanded motion) is a 2-step plan-file handshake — a dry-run writes a JSON plan under ~/.arm101/plans/ whose plan_hash the agent reads and passes back as `--apply --plan-hash <hash>`. The hash is recomputed from live motor state at apply time and refuses on mismatch (stale-state protection); it is written only to the plan file, never to stdout.
+- Attribution + audit for headless writes: an operator identity (ARM101_OPERATOR env -> culture.yaml nick -> tty:$USER) is recorded, and every gated write appends a JSONL `pending` record before and a `success`/`failed` record after to ~/.arm101/audit.log (ARM101_AUDIT_LOG). Audit writes never raise.
+- MotorBus.read_lock() (STS3215 EEPROM Lock register, addr 55) + FakeBus lock_register; the Lock state is surfaced in the center-motor plan snapshot (full unlock->write->relock deferred to a follow-on).
+
+### Changed
+
+- set-motor-id / center-motor no longer hard-refuse a non-TTY stdin (reverses the 0.6.0 up-front non-TTY rejection). A non-TTY caller now gets a read-only dry-run plan by default; the destructive write fires only with an explicit --apply (plus --plan-hash for motion). A piped `yes` still cannot drive a write — consent is an explicit flag against a named target, not stdin content.
+- Default output (without --json) is markdown — the agent-readable format; --json is for application consumers. The explain catalog, overview verb list, and learn prompt were updated in lockstep to document the three modes, the tiers, and --apply/--plan-hash.
+
+### Fixed
+
+- Test isolation: an autouse `tests/conftest.py` fixture pins `ARM101_AUDIT_LOG` and `ARM101_PLAN_DIR` into each test's tmp dir, so the suite can no longer append test records to the operator's real `~/.arm101/audit.log` (the audit-write tests previously leaked there when they did not set the env var themselves). Found during the F1 live-test.
+- Plan-hash verification now tolerates surrounding whitespace: `verify_plan_hash` strips the supplied `--plan-hash` the same way `resolve_consent` does, so a hash read from the plan file with a trailing newline (or copy-pasted with stray spaces) verifies instead of being falsely refused (Qodo).
+- `center-motor` plans now surface the real EEPROM Lock register on hardware: `FeetechBus.read_info` reads addr 55 (`_INFO_REGISTERS`), so `motor_snapshot.lock_register` reflects the actual lock state instead of defaulting to 0 (previously only `FakeBus` injected it) (Qodo).
+- `set-motor-id` `explain` docs no longer claim a non-interactive stdin without `--apply` exits 2 — it prints a read-only dry-run plan and exits 0 (Qodo).
+- Refactored `cmd_center_motor` and `cmd_set_motor_id` into focused helpers (dry-run/confirm/motion/result/audit) to cut cognitive complexity below the gate, and normalized the `# noqa: BLE001` suppression comments (SonarCloud python:S3776, S3358, S7632).
+
 ## [0.6.0] - 2026-06-27
 
 ### Added

{arm101_cli-0.6.0 → arm101_cli-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arm101-cli
-Version: 0.6.0
+Version: 0.7.0
 Summary: Agent and CLI for controlling SO-ARM101 robotic arm grippers
 Project-URL: Homepage, https://github.com/agentculture/arm101-cli
 Project-URL: Issues, https://github.com/agentculture/arm101-cli/issues