agentlaw 0.1.1__tar.gz

agentlaw-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 paranmir
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agentlaw-0.1.1/PKG-INFO

@@ -0,0 +1,206 @@
+Metadata-Version: 2.4
+Name: agentlaw
+Version: 0.1.1
+Summary: Law-first governance kit for AI coding agents: installable scaffold + memory MCP server that lets agents read project rules before they write code.
+Author-email: paranmir <yhntgb444@gmail.com>
+Maintainer-email: paranmir <yhntgb444@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/paranmir/agentlaw
+Project-URL: Repository, https://github.com/paranmir/agentlaw
+Project-URL: Issues, https://github.com/paranmir/agentlaw/issues
+Keywords: llm,agents,memory,mcp,harness,governance
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer<1,>=0.12
+Requires-Dist: mcp<2,>=1.0
+Requires-Dist: sqlite-vec<0.2,>=0.1.6
+Requires-Dist: sentence-transformers<6,>=5.4
+Requires-Dist: huggingface_hub<2,>=1.11
+Requires-Dist: PyYAML<7,>=6.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+# agentlaw
+
+A law-first governance kit for AI coding agents — install governance structure before writing code.
+
+`agentlaw` gives any repository a governed starting structure that AI coding agents can read, follow, and maintain. It works for brand-new repositories and already-existing codebases alike. Drop it in, run the bootstrap, and the agent knows what the rules are before it writes a single line.
+
+> This repository is the **authoring workspace** for agentlaw. The public distribution lives at [`paranmir/agentlaw`](https://github.com/paranmir/agentlaw), and the installable Python package will publish to PyPI as `agentlaw`. Most users want the public repo or the PyPI package; this workspace develops the kit using the kit (recursive improvement).
+
+---
+
+## For Humans
+
+### Install
+
+Once published to PyPI:
+
+```bash
+pipx install agentlaw
+```
+
+While the workspace is still pre-publish, install from this source tree:
+
+```bash
+git clone https://github.com/paranmir/agentlaw-workspace
+cd agentlaw-workspace
+pip install -e .
+```
+
+### Quick Start
+
+```bash
+# 1. Place agentlaw governance into your project
+agentlaw init <your-project-dir>
+
+# 2. Register the agentlaw-memory MCP server with your AI agent host.
+#    The default `--setup-agents prompt` mode emits LLM-actionable
+#    instructions — copy them into your agent and let it edit its host
+#    config. Restart the host after the edit lands.
+
+# 3. Open a fresh chat with your AI agent on the project and say:
+#       Restore the session
+#    The agent loads the harness context and you can start work.
+```
+
+### Using agentlaw in Your AI Coding Session
+
+Once agentlaw is initialized in a project and the `agentlaw-memory` MCP server is registered with your AI agent host, you drive the harness through natural-language triggers in your conversation. The agent maps each trigger to one of the harness's MCP tools and follows the procedure that the kit ships.
+
+**Triggering session restore** — at the start of any new conversation on the project, say one of:
+
+- "Restore the session" / "세션 복원해봐"
+- "Pick up where we left off"
+- "지금 어디까지 했어?"
+
+The agent calls `agentlaw_session_restore`, the response packet carries the project's working set, every active plan body, the most recent session_save log entry, framework reminders (memory intent rule, write discipline, consult-before-answer rule), and a step-by-step reminder of the §Canonical Restore Route Mandatory Tier the agent must follow before answering. The first turn of every session is a context-loading turn; substantive work starts on turn two.
+
+**Triggering session save** — when ending a session, before context compaction, or at any milestone, say one of:
+
+- "Save the session" / "세션 저장해줘"
+- "Wrap up and save state"
+- "Snapshot what we did"
+
+The agent calls `agentlaw_session_save` with the working frame, and the save tool surfaces a post-save verification obligation that you run after.
+
+**When something feels off** — if the agent appears to be answering with stale context or missing rules, ask it to call `agentlaw_session_restore` again, or run `agentlaw mcp-recover --target . --client auto --json` to diagnose MCP connectivity from the shell side.
+
+### What This Project Is
+
+**The problem.** AI coding agents arrive at a repository without governance. They make plausible-looking changes that violate invariants the team has not written down. The team adds a CLAUDE.md or AGENTS.md to capture rules; the file grows; the agent reads less of it; the rules silently stop applying. The agent and the team need shared structure they can both rely on.
+
+**The kit.** agentlaw installs that structure as governance scaffolding: a constitution, a law layer (memory, artifact, oracle, failure rules), root control tools (init / update / fix), contract documents, a memory subsystem (working set, logs, rules, preferences), and a runtime MCP server that surfaces the rules every session. The agent reads the law before it writes; the kit's verifier mechanically catches drift between the rules and the code.
+
+**Recursive improvement.** This authoring workspace develops agentlaw by using agentlaw on itself. Every plan that lands here goes through `AGENTLAW_INIT_TOOL.md` / `AGENTLAW_UPDATE_TOOL.md` / `AGENTLAW_FIX_TOOL.md` rules; every law change is mirrored to the publish-repo seed and to the bundled package scaffold; the same `agentlaw verify` that ships to target projects also runs against this repo. The kit's failures and improvements both surface here first.
+
+### Requirements
+
+- **Python** 3.11 or newer (the kit uses `typing.Literal` unpacking and other 3.11-era stdlib features).
+- **Operating systems**: developed on Windows; Ubuntu and macOS are exercised through the publish-readiness CI matrix.
+- **Disk**: the embedding model occupies roughly 500 MB once downloaded (cached under `<your-project>/.harness/models/`).
+- **Runtime dependencies** are declared in `pyproject.toml` under `[project] dependencies` (currently `typer`, `mcp`, `sqlite-vec`, `sentence-transformers`, `huggingface_hub`, `PyYAML`).
+- **Dev dependencies** (`pip install -e ".[dev]"`): `build`, `pytest`.
+
+### Repository Layout (this authoring workspace)
+
+```
+agentlaw-workspace/
+├── AGENTLAW_CONSTITUTION.md         # highest authority
+├── AGENTLAW_INIT_TOOL.md            # bootstrap entry
+├── AGENTLAW_UPDATE_TOOL.md          # update flow
+├── AGENTLAW_FIX_TOOL.md             # gap-fix flow
+├── AGENTS.md                       # routing-only entry map
+├── README.md                       # this file
+├── docs/
+│   ├── harness/                    # law layer
+│   ├── contracts/                  # contract documents (mirrored to publish-repo)
+│   ├── references/                 # local references (binaries gitignored)
+│   └── plans/                      # active and completed plans
+├── memory/                         # derived continuity (logs, rules, working-set)
+├── publish-repo/                   # PUBLIC distribution seed (separate git repo)
+├── src/agentlaw/                # Python package (CLI, MCP server, init, verify)
+├── tests/                          # pytest suite
+├── sync_package_data.py            # publish-repo → src/agentlaw/scaffold sync
+└── verify_agentlaw.py               # workspace integrity verifier
+```
+
+### Links
+
+- **Public seed** (the kit users install): https://github.com/paranmir/agentlaw
+- **PyPI** (once published): https://pypi.org/project/agentlaw/
+- **This authoring workspace**: https://github.com/paranmir/agentlaw-workspace
+- **Issues**: https://github.com/paranmir/agentlaw/issues
+
+---
+
+## For AI Agents
+
+This section is the agent-facing reading order for first-time entry into the kit. If you are reading this README as a new session on a project that has agentlaw installed, follow the §Canonical Restore Route Mandatory Tier in `docs/law/MEMORY_AND_CONTINUITY_RULES.md` instead — that procedure is the binding one. This README is the on-ramp; the law file is the substance.
+
+### Agent Bootstrap (first install)
+
+When the user asks you to set up agentlaw in a project:
+
+1. Install agentlaw from the approved source. Published path (post-release): `pipx install agentlaw`. Pre-publish source path: `pip install -e .` from this workspace.
+2. Run `agentlaw init <target-project> --setup-agents prompt` in the target. The `prompt` default emits LLM-actionable instructions for registering the `agentlaw-memory` MCP server in your host config; read those instructions and edit your host config rather than letting init auto-write to user-level config (that requires `--setup-agents auto --yes`).
+3. Restart your host after the config edit so the new MCP registration is picked up.
+4. On the next agent session, call `agentlaw_session_restore` (MCP) or `agentlaw session-restore --target . --json` (CLI fallback) and follow the §Canonical Restore Route Mandatory Tier in the response.
+5. If the MCP server is not visible in a new session despite restart, run `agentlaw mcp-recover --target . --client auto --json` to diagnose runtime + registration state.
+
+### Layer-by-layer map (what each artifact class is for)
+
+- **`AGENTLAW_CONSTITUTION.md`** — highest authority; structural invariants. Rare changes; never violate.
+- **Root control tools** (`AGENTLAW_INIT_TOOL.md`, `AGENTLAW_UPDATE_TOOL.md`, `AGENTLAW_FIX_TOOL.md`) — agent-facing procedure documents. Init bootstraps a fresh project, Update incorporates kit upgrades into an existing target, Fix runs the gap-resolution protocol.
+- **`docs/law/*` (law layer)** — rules every session reads: memory and continuity, artifact rules, oracle and judgment, code authorship and stewardship, failure taxonomy, mechanical enforcement policy, starter specialization rules, scope, input/output contract.
+- **`docs/contracts/*`** — boundary surfaces shared with target projects (MCP tool surface, shared baseline, update workflow). Mirrored to publish-repo.
+- **`docs/references/*`** — research-and-context references; not authoritative.
+- **`memory/*`** — derived continuity (working-set, logs, rules, preferences, lookup rules). Below law in authority.
+- **`docs/plans/active/*` and `docs/plans/completed/*`** — work-in-flight and historical work. Active plans are read-on-restore.
+
+### Governing hierarchy
+
+Authority flows top-down:
+
+1. `AGENTLAW_CONSTITUTION.md`
+2. Root control tools
+3. `docs/law/*` (law)
+4. `docs/contracts/*`
+5. `docs/references/*` (non-authoritative)
+6. `memory/*`
+7. `AGENTS.md` (routing only — never a rule store)
+
+When two artifacts seem to conflict, the higher one wins. Memory never overrides law; references never override contracts; AGENTS.md is the entry map, not a source of rules.
+
+### Restore procedure on every session start
+
+§Canonical Restore Route Mandatory Tier (full body in `docs/law/MEMORY_AND_CONTINUITY_RULES.md`) requires 14 steps before composing a substantive response. Summary: confirm runtime integrity, read the working set, read every law file, read every active plan body, read the most recent session_save log entry, scan recent_logs titles, read every active rule's body, read `memory/preferences.md`, read `memory/LOOKUP_RULES.md`, scan the known-facts manifest, run a working-frame `memory_search` over `current_goal + next_actions + open_questions`, inspect governance drift, assemble the packet, surface gaps to the user. The runtime pre-fetches body fields into the restore packet so the substance is in your context without extra `Read` calls; the procedure is binding regardless.
+
+### Critical rules — quick reference
+
+One-line restatements; the binding text lives at the anchors.
+
+- **Memory Intent Rule** — when the user expresses intent to remember, persist, or carry forward, resolve to one of `memory_write` / `promotion_proposal` / `associative_marker` / `explicit_non_save` before final response. Anchor: `docs/law/MEMORY_AND_CONTINUITY_RULES.md` §Memory Intent Rule.
+- **Write Discipline** — silence is a valid answer; a write must clear the §Log Write Criterion three-question gate (and the §Item Write Criterion applicability gate for items). Volume is not the target; selectivity is. Anchor: §Write Discipline.
+- **Read Routing Criterion** — classify the question (prior judgment / cross-session / current source) before reaching for `memory_search` vs `Grep`/`Read`. Anchor: §Read Routing Criterion.
+- **Consult-Before-Answer Rule** — for memory-routed questions, consult memory **before** composing the answer, not after. Anchor: §Consult-Before-Answer Rule.
+- **Self-Narration Prohibition** — governed artifact bodies and code comments describe current state only; revision history lives in plans, tracker entries, memory logs, and git, not in the body. Anchor: `docs/law/REPOSITORY_ARTIFACT_RULES.md` §Self-Narration Prohibition (paired with §Reasoning-Critical Inline Comments in `CODE_AUTHORSHIP_AND_STEWARDSHIP_RULES.md`).
+- **Promotion Proposal Protocol** — runtime never selects promotion candidates; the agent judges whether durability + future operational relevance + authority gap all hold, then calls `memory_propose_promotion`. Anchor: §Promotion Proposal Protocol.
+
+---
+
+## License
+
+MIT. See `LICENSE`.

agentlaw-0.1.1/README.md

@@ -0,0 +1,172 @@
+# agentlaw
+
+A law-first governance kit for AI coding agents — install governance structure before writing code.
+
+`agentlaw` gives any repository a governed starting structure that AI coding agents can read, follow, and maintain. It works for brand-new repositories and already-existing codebases alike. Drop it in, run the bootstrap, and the agent knows what the rules are before it writes a single line.
+
+> This repository is the **authoring workspace** for agentlaw. The public distribution lives at [`paranmir/agentlaw`](https://github.com/paranmir/agentlaw), and the installable Python package will publish to PyPI as `agentlaw`. Most users want the public repo or the PyPI package; this workspace develops the kit using the kit (recursive improvement).
+
+---
+
+## For Humans
+
+### Install
+
+Once published to PyPI:
+
+```bash
+pipx install agentlaw
+```
+
+While the workspace is still pre-publish, install from this source tree:
+
+```bash
+git clone https://github.com/paranmir/agentlaw-workspace
+cd agentlaw-workspace
+pip install -e .
+```
+
+### Quick Start
+
+```bash
+# 1. Place agentlaw governance into your project
+agentlaw init <your-project-dir>
+
+# 2. Register the agentlaw-memory MCP server with your AI agent host.
+#    The default `--setup-agents prompt` mode emits LLM-actionable
+#    instructions — copy them into your agent and let it edit its host
+#    config. Restart the host after the edit lands.
+
+# 3. Open a fresh chat with your AI agent on the project and say:
+#       Restore the session
+#    The agent loads the harness context and you can start work.
+```
+
+### Using agentlaw in Your AI Coding Session
+
+Once agentlaw is initialized in a project and the `agentlaw-memory` MCP server is registered with your AI agent host, you drive the harness through natural-language triggers in your conversation. The agent maps each trigger to one of the harness's MCP tools and follows the procedure that the kit ships.
+
+**Triggering session restore** — at the start of any new conversation on the project, say one of:
+
+- "Restore the session" / "세션 복원해봐"
+- "Pick up where we left off"
+- "지금 어디까지 했어?"
+
+The agent calls `agentlaw_session_restore`, the response packet carries the project's working set, every active plan body, the most recent session_save log entry, framework reminders (memory intent rule, write discipline, consult-before-answer rule), and a step-by-step reminder of the §Canonical Restore Route Mandatory Tier the agent must follow before answering. The first turn of every session is a context-loading turn; substantive work starts on turn two.
+
+**Triggering session save** — when ending a session, before context compaction, or at any milestone, say one of:
+
+- "Save the session" / "세션 저장해줘"
+- "Wrap up and save state"
+- "Snapshot what we did"
+
+The agent calls `agentlaw_session_save` with the working frame, and the save tool surfaces a post-save verification obligation that you run after.
+
+**When something feels off** — if the agent appears to be answering with stale context or missing rules, ask it to call `agentlaw_session_restore` again, or run `agentlaw mcp-recover --target . --client auto --json` to diagnose MCP connectivity from the shell side.
+
+### What This Project Is
+
+**The problem.** AI coding agents arrive at a repository without governance. They make plausible-looking changes that violate invariants the team has not written down. The team adds a CLAUDE.md or AGENTS.md to capture rules; the file grows; the agent reads less of it; the rules silently stop applying. The agent and the team need shared structure they can both rely on.
+
+**The kit.** agentlaw installs that structure as governance scaffolding: a constitution, a law layer (memory, artifact, oracle, failure rules), root control tools (init / update / fix), contract documents, a memory subsystem (working set, logs, rules, preferences), and a runtime MCP server that surfaces the rules every session. The agent reads the law before it writes; the kit's verifier mechanically catches drift between the rules and the code.
+
+**Recursive improvement.** This authoring workspace develops agentlaw by using agentlaw on itself. Every plan that lands here goes through `AGENTLAW_INIT_TOOL.md` / `AGENTLAW_UPDATE_TOOL.md` / `AGENTLAW_FIX_TOOL.md` rules; every law change is mirrored to the publish-repo seed and to the bundled package scaffold; the same `agentlaw verify` that ships to target projects also runs against this repo. The kit's failures and improvements both surface here first.
+
+### Requirements
+
+- **Python** 3.11 or newer (the kit uses `typing.Literal` unpacking and other 3.11-era stdlib features).
+- **Operating systems**: developed on Windows; Ubuntu and macOS are exercised through the publish-readiness CI matrix.
+- **Disk**: the embedding model occupies roughly 500 MB once downloaded (cached under `<your-project>/.harness/models/`).
+- **Runtime dependencies** are declared in `pyproject.toml` under `[project] dependencies` (currently `typer`, `mcp`, `sqlite-vec`, `sentence-transformers`, `huggingface_hub`, `PyYAML`).
+- **Dev dependencies** (`pip install -e ".[dev]"`): `build`, `pytest`.
+
+### Repository Layout (this authoring workspace)
+
+```
+agentlaw-workspace/
+├── AGENTLAW_CONSTITUTION.md         # highest authority
+├── AGENTLAW_INIT_TOOL.md            # bootstrap entry
+├── AGENTLAW_UPDATE_TOOL.md          # update flow
+├── AGENTLAW_FIX_TOOL.md             # gap-fix flow
+├── AGENTS.md                       # routing-only entry map
+├── README.md                       # this file
+├── docs/
+│   ├── harness/                    # law layer
+│   ├── contracts/                  # contract documents (mirrored to publish-repo)
+│   ├── references/                 # local references (binaries gitignored)
+│   └── plans/                      # active and completed plans
+├── memory/                         # derived continuity (logs, rules, working-set)
+├── publish-repo/                   # PUBLIC distribution seed (separate git repo)
+├── src/agentlaw/                # Python package (CLI, MCP server, init, verify)
+├── tests/                          # pytest suite
+├── sync_package_data.py            # publish-repo → src/agentlaw/scaffold sync
+└── verify_agentlaw.py               # workspace integrity verifier
+```
+
+### Links
+
+- **Public seed** (the kit users install): https://github.com/paranmir/agentlaw
+- **PyPI** (once published): https://pypi.org/project/agentlaw/
+- **This authoring workspace**: https://github.com/paranmir/agentlaw-workspace
+- **Issues**: https://github.com/paranmir/agentlaw/issues
+
+---
+
+## For AI Agents
+
+This section is the agent-facing reading order for first-time entry into the kit. If you are reading this README as a new session on a project that has agentlaw installed, follow the §Canonical Restore Route Mandatory Tier in `docs/law/MEMORY_AND_CONTINUITY_RULES.md` instead — that procedure is the binding one. This README is the on-ramp; the law file is the substance.
+
+### Agent Bootstrap (first install)
+
+When the user asks you to set up agentlaw in a project:
+
+1. Install agentlaw from the approved source. Published path (post-release): `pipx install agentlaw`. Pre-publish source path: `pip install -e .` from this workspace.
+2. Run `agentlaw init <target-project> --setup-agents prompt` in the target. The `prompt` default emits LLM-actionable instructions for registering the `agentlaw-memory` MCP server in your host config; read those instructions and edit your host config rather than letting init auto-write to user-level config (that requires `--setup-agents auto --yes`).
+3. Restart your host after the config edit so the new MCP registration is picked up.
+4. On the next agent session, call `agentlaw_session_restore` (MCP) or `agentlaw session-restore --target . --json` (CLI fallback) and follow the §Canonical Restore Route Mandatory Tier in the response.
+5. If the MCP server is not visible in a new session despite restart, run `agentlaw mcp-recover --target . --client auto --json` to diagnose runtime + registration state.
+
+### Layer-by-layer map (what each artifact class is for)
+
+- **`AGENTLAW_CONSTITUTION.md`** — highest authority; structural invariants. Rare changes; never violate.
+- **Root control tools** (`AGENTLAW_INIT_TOOL.md`, `AGENTLAW_UPDATE_TOOL.md`, `AGENTLAW_FIX_TOOL.md`) — agent-facing procedure documents. Init bootstraps a fresh project, Update incorporates kit upgrades into an existing target, Fix runs the gap-resolution protocol.
+- **`docs/law/*` (law layer)** — rules every session reads: memory and continuity, artifact rules, oracle and judgment, code authorship and stewardship, failure taxonomy, mechanical enforcement policy, starter specialization rules, scope, input/output contract.
+- **`docs/contracts/*`** — boundary surfaces shared with target projects (MCP tool surface, shared baseline, update workflow). Mirrored to publish-repo.
+- **`docs/references/*`** — research-and-context references; not authoritative.
+- **`memory/*`** — derived continuity (working-set, logs, rules, preferences, lookup rules). Below law in authority.
+- **`docs/plans/active/*` and `docs/plans/completed/*`** — work-in-flight and historical work. Active plans are read-on-restore.
+
+### Governing hierarchy
+
+Authority flows top-down:
+
+1. `AGENTLAW_CONSTITUTION.md`
+2. Root control tools
+3. `docs/law/*` (law)
+4. `docs/contracts/*`
+5. `docs/references/*` (non-authoritative)
+6. `memory/*`
+7. `AGENTS.md` (routing only — never a rule store)
+
+When two artifacts seem to conflict, the higher one wins. Memory never overrides law; references never override contracts; AGENTS.md is the entry map, not a source of rules.
+
+### Restore procedure on every session start
+
+§Canonical Restore Route Mandatory Tier (full body in `docs/law/MEMORY_AND_CONTINUITY_RULES.md`) requires 14 steps before composing a substantive response. Summary: confirm runtime integrity, read the working set, read every law file, read every active plan body, read the most recent session_save log entry, scan recent_logs titles, read every active rule's body, read `memory/preferences.md`, read `memory/LOOKUP_RULES.md`, scan the known-facts manifest, run a working-frame `memory_search` over `current_goal + next_actions + open_questions`, inspect governance drift, assemble the packet, surface gaps to the user. The runtime pre-fetches body fields into the restore packet so the substance is in your context without extra `Read` calls; the procedure is binding regardless.
+
+### Critical rules — quick reference
+
+One-line restatements; the binding text lives at the anchors.
+
+- **Memory Intent Rule** — when the user expresses intent to remember, persist, or carry forward, resolve to one of `memory_write` / `promotion_proposal` / `associative_marker` / `explicit_non_save` before final response. Anchor: `docs/law/MEMORY_AND_CONTINUITY_RULES.md` §Memory Intent Rule.
+- **Write Discipline** — silence is a valid answer; a write must clear the §Log Write Criterion three-question gate (and the §Item Write Criterion applicability gate for items). Volume is not the target; selectivity is. Anchor: §Write Discipline.
+- **Read Routing Criterion** — classify the question (prior judgment / cross-session / current source) before reaching for `memory_search` vs `Grep`/`Read`. Anchor: §Read Routing Criterion.
+- **Consult-Before-Answer Rule** — for memory-routed questions, consult memory **before** composing the answer, not after. Anchor: §Consult-Before-Answer Rule.
+- **Self-Narration Prohibition** — governed artifact bodies and code comments describe current state only; revision history lives in plans, tracker entries, memory logs, and git, not in the body. Anchor: `docs/law/REPOSITORY_ARTIFACT_RULES.md` §Self-Narration Prohibition (paired with §Reasoning-Critical Inline Comments in `CODE_AUTHORSHIP_AND_STEWARDSHIP_RULES.md`).
+- **Promotion Proposal Protocol** — runtime never selects promotion candidates; the agent judges whether durability + future operational relevance + authority gap all hold, then calls `memory_propose_promotion`. Anchor: §Promotion Proposal Protocol.
+
+---
+
+## License
+
+MIT. See `LICENSE`.

agentlaw-0.1.1/pyproject.toml

@@ -0,0 +1,74 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agentlaw"
+version = "0.1.1"
+description = "Law-first governance kit for AI coding agents: installable scaffold + memory MCP server that lets agents read project rules before they write code."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "paranmir", email = "yhntgb444@gmail.com" }]
+maintainers = [{ name = "paranmir", email = "yhntgb444@gmail.com" }]
+keywords = ["llm", "agents", "memory", "mcp", "harness", "governance"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development",
+    "Topic :: Software Development :: Libraries",
+]
+
+# Upper bounds reflect the security review's stability-hardening
+# recommendation: pin to the next major to prevent silent breakage on a
+# transitive upgrade. Tested floors (`>=`) come from observed compatible
+# behavior; bumps are intentional, not incidental.
+dependencies = [
+    "typer>=0.12,<1",
+    "mcp>=1.0,<2",
+    "sqlite-vec>=0.1.6,<0.2",
+    # Narrow ranges on the embedding stack: offline semantics
+    # (HF_HUB_OFFLINE, local_files_only=True) have changed silently across
+    # minor releases of both libraries. Freezing the tested range prevents
+    # a transitive upgrade from silently re-enabling Hub contact and
+    # resurrecting the 2026-04-24 first-call hang.
+    "sentence-transformers>=5.4,<6",
+    "huggingface_hub>=1.11,<2",
+    "PyYAML>=6.0,<7",
+]
+
+[project.optional-dependencies]
+dev = [
+    "build>=1.2",
+    "pytest>=8",
+]
+
+[project.scripts]
+agentlaw = "agentlaw.cli:app"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = [
+    "package: package build/install smoke tests; skipped unless HARNESS_RUN_PACKAGE_SMOKE=1.",
+    "slow: tests that download the embedding model or do heavy IO; excluded from default runs. Run with `pytest -m slow` to include.",
+]
+addopts = "-m 'not slow' -ra"
+
+[project.urls]
+Homepage = "https://github.com/paranmir/agentlaw"
+Repository = "https://github.com/paranmir/agentlaw"
+Issues = "https://github.com/paranmir/agentlaw/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+agentlaw = [
+    "schema/*.sql",
+    "scaffold/**/*",
+]

agentlaw-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

agentlaw-0.1.1/src/agentlaw/__init__.py

@@ -0,0 +1,3 @@
+"""Agent Law — installable governance scaffold and memory MCP server."""
+
+__version__ = "0.1.0"

agentlaw-0.1.1/src/agentlaw/__main__.py

@@ -0,0 +1,4 @@
+from agentlaw.cli import app
+
+if __name__ == "__main__":
+    app()

agentlaw-0.1.1/src/agentlaw/agent_setup/__init__.py

@@ -0,0 +1,5 @@
+"""Agent host setup orchestration."""
+
+from agentlaw.agent_setup.runner import run_agent_setup
+
+__all__ = ["run_agent_setup"]