agentic-development-framework 0.1.0__tar.gz → 0.2.0__tar.gz

{agentic_development_framework-0.1.0 → agentic_development_framework-0.2.0}/CHANGELOG.md

@@ -4,6 +4,29 @@ All notable changes to this project will be documented in this file.
 
 ## Unreleased
 
+## 0.2.0 - 2026-11-02
+
+### Added
+
+- Machine-readable IDE-agent stage execution contracts for all nineteen workflow stages.
+- Persistent execution attempts, current tasks, blockers, errors, and explicit stage-completion
+  commands.
+- SHA-256 artifact validation, mandatory approval gates, revision feedback, and preserved review
+  snapshots.
+- Additive runtime schema migration plus Antigravity execution and recovery documentation.
+- Command-named Antigravity workspace skills so `/continue` invokes IDE-agent execution rather
+  than relying on rule interpretation alone.
+- State-aware `/adf` requests, `/adf-resume`, and safe project-specific slash-command generation.
+
+### Changed
+
+- `adt continue` now prepares or resumes the current stage and cannot silently advance it.
+- Project initialization completes its own stage and leaves project discovery pending for the IDE
+  agent.
+- Clean-install acceptance now validates generated Antigravity command skills and stage execution.
+
+## 0.1.0 - 2026-11-02
+
 ### Added
 
 - Initial package and CLI foundation.

{agentic_development_framework-0.1.0 → agentic_development_framework-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-development-framework
-Version: 0.1.0
+Version: 0.2.0
 Summary: A local-first framework for agentic software development workflows.
 Project-URL: Homepage, https://github.com/Badsha-ugv/ide-agentic-development-framework
 Project-URL: Repository, https://github.com/Badsha-ugv/ide-agentic-development-framework
@@ -38,7 +38,8 @@ human-controlled software development workflows driven through IDE coding agents
 The project is being delivered incrementally. The current implementation provides the
 installable package, strict configuration validation, structured logging, safe project
 initialization, immutable requirements versioning, SQLite workflow state, recovery checkpoints,
-lifecycle commands, and Codex/Antigravity project configuration.
+lifecycle commands, structured stage execution contracts, artifact validation, approval history,
+and Codex/Antigravity project configuration.
 
 ## Requirements
 
@@ -78,11 +79,19 @@ adt status
 adt pause
 adt resume
 adt continue
+adt stage show
+adt stage task "custom stage-scoped task"
+adt artifact register docs/discovery/project-overview.md
+adt artifact list
+adt stage complete
+adt stage fail --blocked "Clarification required"
 adt stop
 adt review
 adt approve requirements_review
 adt revise requirements_review "Clarify the acceptance criteria"
 adt tasks
+adt command create verify-api "Run the current-stage API checks"
+adt command list
 ```
 
 The validation command prints the normalized configuration as YAML and exits with code 2
@@ -134,16 +143,45 @@ Initialization creates `.agentic/database/agentic.db` as the transactional sourc
 inspection snapshots under `.agentic/state/`, a JSONL event history, and checkpoint storage.
 Pause and stop persist checkpoints. Resume verifies checkpoint integrity and restores the
 checkpoint stage instead of trusting potentially inconsistent conversational context or snapshot
-files. Mandatory workflow approval stages cannot advance until approval is recorded.
+files. Execution status, current task, attempts, errors, blockers, registered artifact hashes,
+approvals, and revisions survive IDE and computer restarts. Mandatory workflow approval stages
+cannot advance until approval is recorded.
+
+`adt start` and `adt continue` prepare the current stage; they do not pretend that an AI task was
+completed and never silently skip deliverables. The IDE agent performs reasoning and file changes
+using `.agentic/execution-contracts.yaml`. It registers each output with `adt artifact register`,
+then uses `adt stage complete` to validate and advance. Review stages stop at
+`awaiting_approval` until an explicit `adt approve` or `adt revise` operation. See
+[`docs/WORKFLOW_ARCHITECTURE.md`](docs/WORKFLOW_ARCHITECTURE.md),
+[`docs/COMMAND_REFERENCE.md`](docs/COMMAND_REFERENCE.md), and
+[`docs/STAGE_EXECUTION.md`](docs/STAGE_EXECUTION.md).
 
 ## IDE configuration
 
-ADF generates root `AGENTS.md`, a shared command skill under
-`.agents/skills/agentic-commands/`, and Antigravity rules under `.agents/rules/`. The Codex adapter
+ADF generates root `AGENTS.md`, command-named Antigravity skills under `.agents/skills/`, a shared
+execution protocol under `.agents/skills/agentic-commands/`, and rules under `.agents/rules/`.
+Antigravity indexes each skill as `/<skill-name>`, so `/continue` invokes the generated `continue`
+skill and causes the IDE agent—not the terminal process—to execute the current stage. The Codex adapter
 uses the documented root instructions and repository-local skill surfaces. The `.codex/agents/`
 directory contains an informational compatibility note; ADF does not claim an undocumented
 custom-agent file format is automatically discovered.
 
+After `adt init` and `adt requirements ingest`, open the project root in Antigravity and type
+`/continue`. Generated rules instruct the agent to load the current contract, perform project
+discovery, create and register its four discovery documents, and persist a blocker instead of
+fabricating missing answers. See [`docs/ANTIGRAVITY_SETUP.md`](docs/ANTIGRAVITY_SETUP.md) and
+[`docs/APPROVALS_AND_REVISIONS.md`](docs/APPROVALS_AND_REVISIONS.md).
+
+Use `/adf <request>` for an ad hoc request that must remain bound to the current stage and status.
+To register a reusable project-specific slash command, run `adt command create NAME
+"INSTRUCTIONS"`; `/NAME` then performs the same persisted-state and contract preflight. Because
+Antigravity reserves `/resume` for its conversation feature, ADF checkpoint recovery is exposed as
+`/adf-resume`.
+
+For projects initialized by an earlier ADF version, upgrade the package and rerun `adt init`.
+SQLite schema migration is automatic and additive. New managed files are created, while conflicts
+with customized guidance are preserved as `.agentic/proposals/**/*.proposed` for manual review.
+
 ## Configuration
 
 ADF configuration uses YAML and rejects unknown keys to catch mistakes early:

{agentic_development_framework-0.1.0 → agentic_development_framework-0.2.0}/README.md

@@ -6,7 +6,8 @@ human-controlled software development workflows driven through IDE coding agents
 The project is being delivered incrementally. The current implementation provides the
 installable package, strict configuration validation, structured logging, safe project
 initialization, immutable requirements versioning, SQLite workflow state, recovery checkpoints,
-lifecycle commands, and Codex/Antigravity project configuration.
+lifecycle commands, structured stage execution contracts, artifact validation, approval history,
+and Codex/Antigravity project configuration.
 
 ## Requirements
 
@@ -46,11 +47,19 @@ adt status
 adt pause
 adt resume
 adt continue
+adt stage show
+adt stage task "custom stage-scoped task"
+adt artifact register docs/discovery/project-overview.md
+adt artifact list
+adt stage complete
+adt stage fail --blocked "Clarification required"
 adt stop
 adt review
 adt approve requirements_review
 adt revise requirements_review "Clarify the acceptance criteria"
 adt tasks
+adt command create verify-api "Run the current-stage API checks"
+adt command list
 ```
 
 The validation command prints the normalized configuration as YAML and exits with code 2
@@ -102,16 +111,45 @@ Initialization creates `.agentic/database/agentic.db` as the transactional sourc
 inspection snapshots under `.agentic/state/`, a JSONL event history, and checkpoint storage.
 Pause and stop persist checkpoints. Resume verifies checkpoint integrity and restores the
 checkpoint stage instead of trusting potentially inconsistent conversational context or snapshot
-files. Mandatory workflow approval stages cannot advance until approval is recorded.
+files. Execution status, current task, attempts, errors, blockers, registered artifact hashes,
+approvals, and revisions survive IDE and computer restarts. Mandatory workflow approval stages
+cannot advance until approval is recorded.
+
+`adt start` and `adt continue` prepare the current stage; they do not pretend that an AI task was
+completed and never silently skip deliverables. The IDE agent performs reasoning and file changes
+using `.agentic/execution-contracts.yaml`. It registers each output with `adt artifact register`,
+then uses `adt stage complete` to validate and advance. Review stages stop at
+`awaiting_approval` until an explicit `adt approve` or `adt revise` operation. See
+[`docs/WORKFLOW_ARCHITECTURE.md`](docs/WORKFLOW_ARCHITECTURE.md),
+[`docs/COMMAND_REFERENCE.md`](docs/COMMAND_REFERENCE.md), and
+[`docs/STAGE_EXECUTION.md`](docs/STAGE_EXECUTION.md).
 
 ## IDE configuration
 
-ADF generates root `AGENTS.md`, a shared command skill under
-`.agents/skills/agentic-commands/`, and Antigravity rules under `.agents/rules/`. The Codex adapter
+ADF generates root `AGENTS.md`, command-named Antigravity skills under `.agents/skills/`, a shared
+execution protocol under `.agents/skills/agentic-commands/`, and rules under `.agents/rules/`.
+Antigravity indexes each skill as `/<skill-name>`, so `/continue` invokes the generated `continue`
+skill and causes the IDE agent—not the terminal process—to execute the current stage. The Codex adapter
 uses the documented root instructions and repository-local skill surfaces. The `.codex/agents/`
 directory contains an informational compatibility note; ADF does not claim an undocumented
 custom-agent file format is automatically discovered.
 
+After `adt init` and `adt requirements ingest`, open the project root in Antigravity and type
+`/continue`. Generated rules instruct the agent to load the current contract, perform project
+discovery, create and register its four discovery documents, and persist a blocker instead of
+fabricating missing answers. See [`docs/ANTIGRAVITY_SETUP.md`](docs/ANTIGRAVITY_SETUP.md) and
+[`docs/APPROVALS_AND_REVISIONS.md`](docs/APPROVALS_AND_REVISIONS.md).
+
+Use `/adf <request>` for an ad hoc request that must remain bound to the current stage and status.
+To register a reusable project-specific slash command, run `adt command create NAME
+"INSTRUCTIONS"`; `/NAME` then performs the same persisted-state and contract preflight. Because
+Antigravity reserves `/resume` for its conversation feature, ADF checkpoint recovery is exposed as
+`/adf-resume`.
+
+For projects initialized by an earlier ADF version, upgrade the package and rerun `adt init`.
+SQLite schema migration is automatic and additive. New managed files are created, while conflicts
+with customized guidance are preserved as `.agentic/proposals/**/*.proposed` for manual review.
+
 ## Configuration
 
 ADF configuration uses YAML and rejects unknown keys to catch mistakes early:

agentic_development_framework-0.2.0/docs/ANTIGRAVITY_SETUP.md

@@ -0,0 +1,58 @@
+# Antigravity setup
+
+Run these commands in the target project:
+
+```bash
+adt init
+adt requirements ingest
+```
+
+Then open the project root in Antigravity. ADF generates:
+
+- root `AGENTS.md` project guidance;
+- `.agents/rules/adf.md` command interpretation rules;
+- `.agents/skills/<command>/SKILL.md` files that register commands such as `/continue`;
+- `.agents/skills/agentic-commands/SKILL.md` with the shared execution loop;
+- `.agents/skills/adf/SKILL.md` for state-aware custom requests;
+- `.agents/skills/adf-resume/SKILL.md` for ADF checkpoint recovery; and
+- `.agentic/execution-contracts.yaml` with stage-specific responsibilities and outputs.
+
+Start a new conversation and type `/continue`. Antigravity should interpret it as an ADF request,
+run `adt start` when the workflow is not active or `adt continue` when it is active, execute the
+reported stage, and persist its artifacts. ADF does not install a proprietary slash-command
+extension. Modern Antigravity directly indexes workspace skills and invokes a skill named
+`continue` as `/continue`. Legacy `.agents/workflows/` files are intentionally not generated,
+because Antigravity stopped indexing them on October 19, 2026.
+
+Running `adt continue` in an ordinary terminal does **not** call the Antigravity model. It only
+prepares and persists the current stage. Invoking `/continue` in Antigravity loads the generated
+skill, so the IDE agent calls the CLI, reads the contract, reasons about the project, writes and
+registers artifacts, and completes or blocks the stage.
+
+For an ad hoc request tied to durable state, type `/adf <request>`. To add a reusable custom slash
+command:
+
+```bash
+adt command create verify-api "Run API verification relevant to the current stage"
+```
+
+Antigravity then exposes `/verify-api`. The wrapper always reads status and the current contract,
+persists its task with `adt stage task`, and refuses to skip prerequisites or approval gates.
+Existing skill files are preserved and cannot be overwritten by this command.
+
+Antigravity already owns `/resume` for conversation recovery. Use `/adf-resume` when you mean ADF
+checkpoint recovery.
+
+If the agent only prints CLI state, ask it to re-read the generated `agentic-commands` skill and
+execution contract. Confirm the installed framework version contains the current skill, then rerun
+`adt init`. Existing customized generated files are never overwritten; inspect corresponding
+`.agentic/proposals/**/*.proposed` files and merge the update deliberately.
+
+After creating or upgrading skills, reopen the project or start a new Antigravity chat if the
+slash-command autocomplete has not refreshed.
+
+Use `adt status`, `adt artifact list`, and `adt stage show` to verify durable state independently of
+the IDE conversation.
+
+References: [Antigravity workflows-to-skills migration](https://antigravity.google/docs/migration/workflows-to-skills/)
+and [Antigravity workflow documentation](https://antigravity.google/docs/ide/workflows/).

agentic_development_framework-0.2.0/docs/APPROVALS_AND_REVISIONS.md

@@ -0,0 +1,24 @@
+# Approvals and revisions
+
+Requirements, architecture, design, and release review are mandatory human approval gates.
+Creating documents does not approve them.
+
+When `adt stage complete` validates a review stage, its execution becomes `awaiting_approval` and
+the workflow remains on that stage. Use `adt review` to inspect registered deliverables. Only an
+explicit `adt approve STAGE` records approval and advances.
+
+To request changes:
+
+```bash
+adt revise requirements_review "Clarify administrator permissions and acceptance criteria"
+```
+
+ADF copies the submitted registered artifacts to
+`.agentic/revisions/STAGE/revision-N/`, records the feedback and snapshot path in SQLite, and
+returns the same stage to `in_progress`. The IDE agent updates only affected working documents,
+registers their new hashes, revalidates all deliverables, and runs `adt stage complete` again.
+Approval is requested again; revision feedback never implies approval.
+
+Revision snapshots, artifact metadata revisions, approval state, event history, and checkpoints
+survive process and IDE restarts. The normal project documents remain the editable working copy;
+the snapshot is the immutable review-history evidence.

agentic_development_framework-0.2.0/docs/COMMAND_REFERENCE.md

@@ -0,0 +1,40 @@
+# Command reference
+
+Commands are available as CLI operations. Antigravity discovers workspace skills at
+`.agents/skills/<name>/SKILL.md` and exposes them as `/<name>`. ADF generates command-named skills
+that delegate to the shared `agentic-commands` execution protocol.
+
+| IDE request | CLI operation | Contract |
+|---|---|---|
+| `/start` | `adt start` | Activate and prepare the first pending stage; the IDE agent then executes it. |
+| `/continue` | `adt continue` | Prepare or resume the current stage; never silently advance. |
+| `/status` | `adt status` | Show workflow stage, execution state, current task, attempts, approval, artifacts, errors, and blockers. |
+| `/pause` | `adt pause` | Pause and create a checkpoint. |
+| `/adf-resume` | `adt resume`, then `adt continue` | Validate the latest checkpoint, restore its stage, and continue IDE-agent execution. Antigravity owns the built-in `/resume`. |
+| `/stop` | `adt stop` | Stop and checkpoint without deleting progress. |
+| `/review` | `adt review` | List pending/revision-requested gates and registered deliverables. |
+| `/approve STAGE` | `adt approve STAGE` | Explicitly approve the current waiting gate and advance. |
+| `/revise STAGE FEEDBACK` | `adt revise STAGE FEEDBACK` | Preserve the submitted version, store feedback, and reopen the same stage. |
+| `/help` | `adt help` | Explain framework commands. |
+
+Execution support commands:
+
+```bash
+adt stage show
+adt stage task "custom stage-scoped request"
+adt artifact register docs/discovery/project-overview.md
+adt artifact list
+adt stage complete
+adt stage fail "test command failed"
+adt stage fail --blocked "Product owner must answer the retention question"
+adt command create verify-api "Run API verification relevant to the current stage"
+adt command list
+```
+
+`adt stage complete` is the normal advancement operation. It fails when required outputs are
+missing, empty, unregistered, or changed after registration. Re-register a changed file before
+retrying completion.
+
+`/adf <request>` is the generic state-aware entry point. A command created with `adt command create`
+also performs status and contract preflight, persists its current task, and cannot bypass stage
+prerequisites, policy, validation, or approvals.

{agentic_development_framework-0.1.0 → agentic_development_framework-0.2.0}/docs/IMPLEMENTATION_PROGRESS.md

@@ -69,7 +69,7 @@ future SQLite runtime and command registry.
 
 ## Phase 3 — Runtime and persistence
 
-Status: core acceptance scope complete (2026-11-02)
+Status: persistent execution scope complete (2026-11-02)
 
 - [x] SQLite schema and idempotent initialization
 - [x] Persistent workflow, task, approval, checkpoint, and event tables
@@ -77,23 +77,32 @@ Status: core acceptance scope complete (2026-11-02)
 - [x] JSONL event history
 - [x] Integrity-checked pause/stop checkpoints
 - [x] Cross-process recovery from the verified checkpoint stage
+- [x] Additive schema-v2 migration for existing initialized projects
+- [x] Persistent stage status, current task, attempts, blockers, and errors
+- [x] SHA-256 artifact registration and metadata revisions
+- [x] Approval feedback and immutable submitted-revision snapshots
 
 ## Phase 4 — Command system
 
-Status: lifecycle acceptance scope complete (2026-11-02)
+Status: execution-aware lifecycle scope complete (2026-11-02)
 
 - [x] Central command registry
 - [x] Start, status, pause, resume, continue, stop, and help
 - [x] Review, approve, revise, requirements, and tasks
 - [x] Expected failures return actionable errors without tracebacks
+- [x] Continue prepares/resumes the current stage without silently advancing
+- [x] Stage contract inspection, artifact registration/listing, completion, failure, and blockers
 
 ## Phase 6 — Agent and workflow system
 
-Status: configuration foundation complete; execution remains incomplete
+Status: IDE-agent execution contract complete; specialist delegation remains incremental
 
 - [x] Canonical configurable lifecycle with approval metadata
 - [x] Eleven canonical agent definitions and safety fields
 - [x] Approval-gate enforcement
+- [x] Structured execution contracts for all nineteen lifecycle stages
+- [x] Deliverable presence, non-empty content, and registered-hash validation
+- [x] Discovery, requirements, architecture, design, planning, delivery, and release outputs
 - [ ] Task dependencies and genuine sequential specialist execution
 
 ## Phase 7 — IDE adapters
@@ -104,6 +113,10 @@ Status: Codex and Antigravity acceptance scope complete; VS Code remains incompl
 - [x] Validated repository-local Codex command skill
 - [x] Antigravity rules and shared skill
 - [x] Explicit documentation of unsupported/undocumented custom-agent discovery
+- [x] Real command-named Antigravity skills for `/start`, `/continue`, status, and review actions
+- [x] `/adf-resume` recovery command that avoids Antigravity's built-in `/resume` collision
+- [x] State-aware `/adf <request>` and safe custom slash-command generation
+- [x] Antigravity setup, command, stage execution, approval, and migration documentation
 - [ ] VS Code agent-environment generation and validation
 
 ## Release acceptance review
@@ -125,7 +138,7 @@ Status: PyPI 0.1.0 release gates passed (2026-11-02)
 
 ## Remaining phases
 
-Phase 8, Phase 9, the VS Code portion of Phase 7, and the execution portion of Phase 6 remain on
-the broader framework roadmap. They are not represented as implemented in the 0.1.0 alpha release;
-their scope and dependencies are documented in `docs/IMPLEMENTATION_PLAN.md`.
+Phase 8, broader Phase 9 integrations, the VS Code portion of Phase 7, and native AI-provider
+integration remain on the roadmap. IDE agents are the supported reasoning layer; the CLI does not
+embed or call a paid model API. These changes are included in the 0.2.0 release candidate.
 

{agentic_development_framework-0.1.0 → agentic_development_framework-0.2.0}/docs/PYPI_RELEASE.md

@@ -84,8 +84,8 @@ Review the complete diff and confirm CI on `main` is green. Then create and push
 git switch main
 git pull --ff-only
 git status --short
-git tag -s v0.1.0 -m "Release 0.1.0"
-git push origin v0.1.0
+git tag -s v0.2.0 -m "Release 0.2.0"
+git push origin v0.2.0
 ```
 
 Use an annotated unsigned tag (`git tag -a`) only if signed tags are not available. Do not reuse a
@@ -104,7 +104,7 @@ must all pass before the OIDC publishing job can run.
    ```bash
    verify_tmp="$(mktemp -d)"
    python -m venv "$verify_tmp/venv"
-   "$verify_tmp/venv/bin/python" -m pip install agentic-development-framework==0.1.0
+   "$verify_tmp/venv/bin/python" -m pip install agentic-development-framework==0.2.0
    "$verify_tmp/venv/bin/adt" --version
    "$verify_tmp/venv/bin/adt" --help
    ```

agentic_development_framework-0.2.0/docs/STAGE_EXECUTION.md

@@ -0,0 +1,36 @@
+# Stage execution guide
+
+Every initialized project receives `.agentic/execution-contracts.yaml`. Each contract contains a
+stage ID and name, objective, prerequisites, required inputs, specialist role, responsibilities,
+instructions, expected outputs, validation criteria, completion conditions, approval requirement,
+failure behavior, and retry limit.
+
+## IDE-agent loop
+
+For `/start`, `/continue`, and `/adf-resume`, the agent must:
+
+1. inspect `adt status` and prepare the current stage;
+2. select that stage from `.agentic/execution-contracts.yaml`;
+3. read all available required inputs and relevant source;
+4. perform the responsibilities without fabricating missing facts;
+5. ask questions and persist an actionable blocker when material information is absent;
+6. create every expected output and run its validation criteria;
+7. register every output's current bytes;
+8. complete the stage, or record a failure/blocker; and
+9. summarize artifacts, checks, state, and next user action.
+
+Project discovery produces:
+
+- `docs/discovery/project-overview.md`
+- `docs/discovery/stakeholder-analysis.md`
+- `docs/discovery/clarification-log.md`
+- `docs/discovery/assumptions-and-risks.md`
+
+Facts, assumptions, risks, and open questions must remain distinct. Missing product decisions go
+into the clarification log; the agent must not invent answers. Requirements stages then create
+stable IDs, acceptance criteria, traceability, and the SRS before the requirements approval gate.
+
+Later contracts cover architecture, a Figma-backed or local interactive design prototype,
+development planning, implementation, integration, testing, review, delivery validation,
+documentation, and release review. The contract file—not conversational memory—is the durable
+definition of the next work.

agentic_development_framework-0.2.0/docs/WORKFLOW_ARCHITECTURE.md

@@ -0,0 +1,45 @@
+# Workflow architecture
+
+ADF separates reasoning from durable control.
+
+The IDE agent is the execution layer. It reads project inputs, applies a specialist role, asks
+questions, writes artifacts, and runs verification. The `adt` CLI is the control plane. It does
+not contain an AI provider and cannot honestly claim that analysis occurred. It persists workflow
+and execution state in SQLite, registers artifact hashes, validates completion, enforces approval
+gates, creates checkpoints, and records retries.
+
+## Transition model
+
+Each stage follows this sequence:
+
+1. `adt start` or `adt continue` changes the current execution to `in_progress` and returns its
+   contract. It never completes or advances the stage.
+2. The IDE agent reads `.agentic/execution-contracts.yaml`, inspects inputs, performs the work, and
+   creates the required outputs.
+3. `adt artifact register PATH` records the stage, path, byte size, SHA-256, and metadata revision.
+4. `adt stage complete` verifies that every output pattern resolves to non-empty files and that
+   every file's current hash is registered.
+5. A normal stage becomes `completed` and advances. A review stage becomes `awaiting_approval` and
+   does not advance.
+6. `adt approve STAGE` records explicit approval, completes the review stage, and advances.
+   `adt revise STAGE FEEDBACK` snapshots the submitted files and returns the same stage to
+   `in_progress`.
+
+SQLite under `.agentic/database/` is authoritative. JSON files under `.agentic/state/` are
+inspection snapshots only. Requirements source versions remain independently immutable under
+`requirements/versions/`.
+
+## Recovery
+
+Pause and stop create integrity-checked checkpoints. Resume validates the newest checkpoint and
+restores its stage. Stage execution rows retain the current task, attempt count, blocker, error,
+timestamps, and completion state across IDE sessions. Artifact, approval, and revision records are
+included in checkpoints.
+
+## Compatibility
+
+Schema version 1 databases are upgraded additively to schema version 2 when any workflow command
+opens them. Existing workflow rows, requirements versions, tasks, approvals, checkpoints, and
+events are preserved. Re-run `adt init` after upgrading ADF to install newly introduced managed
+files. Conflicting generated instructions are preserved and updated content is written below
+`.agentic/proposals/` for review rather than overwriting project customizations.

{agentic_development_framework-0.1.0 → agentic_development_framework-0.2.0}/scripts/release_acceptance.py

@@ -64,9 +64,13 @@ def _verify_files(root: Path) -> None:
         "AGENTS.md",
         ".agents/rules/adf.md",
         ".agents/skills/agentic-commands/SKILL.md",
+        ".agents/skills/continue/SKILL.md",
+        ".agents/skills/adf/SKILL.md",
+        ".agents/skills/adf-resume/SKILL.md",
         ".codex/agents/README.md",
         ".agentic/config.yaml",
         ".agentic/workflow.yaml",
+        ".agentic/execution-contracts.yaml",
         ".agentic/policies.yaml",
         ".agentic/agent-registry.yaml",
         ".agentic/database/agentic.db",
@@ -92,12 +96,21 @@ def _verify_files(root: Path) -> None:
 def _verify_database(root: Path) -> None:
     database = root / ".agentic/database/agentic.db"
     with closing(sqlite3.connect(database)) as connection:
-        assert connection.execute("PRAGMA user_version").fetchone()[0] == 1
+        assert connection.execute("PRAGMA user_version").fetchone()[0] == 2
         tables = {
             row[0]
             for row in connection.execute("SELECT name FROM sqlite_master WHERE type='table'")
         }
-    assert {"workflow", "tasks", "approvals", "checkpoints", "events"} <= tables
+    assert {
+        "workflow",
+        "tasks",
+        "approvals",
+        "checkpoints",
+        "events",
+        "stage_executions",
+        "artifacts",
+        "revisions",
+    } <= tables
 
 
 def run_acceptance(artifact: Path) -> dict[str, object]:
@@ -117,7 +130,16 @@ def run_acceptance(artifact: Path) -> dict[str, object]:
         adt = environment / "bin" / "adt"
         _run([str(python), "-m", "pip", "install", str(artifact)], cwd=root)
         assert "Local-first agentic development" in _run([str(adt), "--help"], cwd=root)
-        assert "adt 0.1.0" in _run([str(adt), "--version"], cwd=root)
+        installed_version = _run(
+            [
+                str(python),
+                "-c",
+                "import importlib.metadata; "
+                "print(importlib.metadata.version('agentic-development-framework'))",
+            ],
+            cwd=root,
+        ).strip()
+        assert f"adt {installed_version}" in _run([str(adt), "--version"], cwd=root)
         assert "Local-first agentic development" in _run(
             [str(python), "-m", "agentic_framework", "--help"], cwd=root
         )
@@ -131,7 +153,7 @@ def run_acceptance(artifact: Path) -> dict[str, object]:
         _verify_files(new_project)
         _verify_database(new_project)
         assert "Project mode: new" in new_init
-        assert "Created files: 10" in new_init
+        assert "Created files: 24" in new_init
         assert "Created files: 0" in new_second_init
 
         init_output = _run([str(adt), "init", "--no-git"], cwd=root)
@@ -145,7 +167,7 @@ def run_acceptance(artifact: Path) -> dict[str, object]:
         report = (root / ".agentic/reports/initialization.md").read_text(encoding="utf-8")
         assert "Django" in report and "JavaScript" in report and "npm" in report
         assert "Project mode: existing" in init_output
-        assert "Created files: 9" in init_output
+        assert "Created files: 23" in init_output
         assert "Conflicts: 1" in init_output
         assert "Created files: 0" in second_init
         assert "Conflicts: 1" in second_init
@@ -165,8 +187,22 @@ def run_acceptance(artifact: Path) -> dict[str, object]:
 
         assert "Status: active" in _run([str(adt), "start"], cwd=root)
         assert "project_discovery" in _run([str(adt), "continue"], cwd=root)
+        discovery_outputs = (
+            "docs/discovery/project-overview.md",
+            "docs/discovery/stakeholder-analysis.md",
+            "docs/discovery/clarification-log.md",
+            "docs/discovery/assumptions-and-risks.md",
+        )
+        for relative in discovery_outputs:
+            output = root / relative
+            output.write_text(f"# {output.stem}\n\nAcceptance evidence.\n", encoding="utf-8")
+            assert "Registered:" in _run(
+                [str(adt), "artifact", "register", relative], cwd=root
+            )
+        completion = _run([str(adt), "stage", "complete"], cwd=root)
+        assert "requirements_ingestion" in completion
         assert "Status: paused" in _run([str(adt), "pause"], cwd=root)
-        assert "project_discovery" in _run([str(adt), "status"], cwd=root)
+        assert "requirements_ingestion" in _run([str(adt), "status"], cwd=root)
         assert "Status: active" in _run([str(adt), "resume"], cwd=root)
         assert "Status: stopped" in _run([str(adt), "stop"], cwd=root)
         assert "Status: active" in _run([str(adt), "resume"], cwd=root)

{agentic_development_framework-0.1.0 → agentic_development_framework-0.2.0}/src/agentic_framework/__init__.py

@@ -1,6 +1,6 @@
 """Agentic Development Framework public package metadata."""
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 
 __all__ = ["__version__"]