slipwai 1.0.1.dev7__tar.gz → 1.0.1.dev10__tar.gz

{slipwai-1.0.1.dev7 → slipwai-1.0.1.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: slipwai
-Version: 1.0.1.dev7
+Version: 1.0.1.dev10
 Summary: One-shot scaffolder for product monorepos: a walking skeleton, a verify gate, a path to production, and a repository set up for coding agents.
 Project-URL: Homepage, https://github.com/ROBCOATVG/slipwai
 Project-URL: Repository, https://git.treyco.dev/ROBCOATVG/slipwai

slipwai-1.0.1.dev10/VERSION

@@ -0,0 +1 @@
+1.0.1.dev10

{slipwai-1.0.1.dev7 → slipwai-1.0.1.dev10}/assets/toolkit/docs/delegated-agent-safety.md

@@ -12,7 +12,16 @@ brief from carrying an incomplete copy of either.
   implementation delegate may edit only the files its manifest names. Stop and report when another change
   is needed.
 - Preserve work already in the checkout. Never use `git stash`, never use `git checkout` without the exact
-  path and intent, and never copy a tracked file aside as a backup.
+  path and intent, and never copy a tracked file aside as a backup. The one sanctioned way to observe a
+  failure without leaving the tree dirty — to check an assertion has teeth, or to see a RED on code that
+  already exists — is to change the production file, run the test, and restore that file with
+  `git checkout -- <exact path>`. A prohibition with no legal route gets routed around by exactly the
+  delegates trying hardest to do the job well; this is the route.
+- A delegate that edits the tree as part of its *method* rather than its output — a converge pass mutating
+  code to prove a finding, an implementation delegate checking an assertion discriminates — owns leaving it
+  clean on every exit path, including being stopped: branch or commit before the first such edit, restore
+  each file before the next, and report what was touched. A stopped pass once left a mutation live in the
+  tree the demo was next to run from.
 - Do not stop processes by command-line pattern: `pkill -f <pattern>` can match the shell issuing it. Stop only
   a PID the task started and recorded.
 - Leave existing long-lived processes running, including development servers, demos, watchers and backing

{slipwai-1.0.1.dev7 → slipwai-1.0.1.dev10}/assets/toolkit/scripts/agents/project.py

@@ -656,6 +656,9 @@ def main() -> None:
                     if isinstance(harness.get("agentFile"), dict)
                     else "Project skills and commands installed")
             print(f'{done} for {harness["name"]} ({key}).')
+            if isinstance(harness.get("agentFile"), dict) and not CONTEXT_ONLY:
+                print("A harness reads its agent types once, at session start: restart the session before "
+                      "delegating, or the first delegation cannot use the types just projected.")
     if CHECK:
         if FINDINGS:
             raise RuntimeError("agent projection drift:\n  - " + "\n  - ".join(FINDINGS))

slipwai-1.0.1.dev10/changelog.d/drive-bounded-convergence.md

@@ -0,0 +1,20 @@
+PATCH
+
+**`/drive` bounds its convergence loop, checks the branch before it reads the artifacts, and gives a
+delegate the one legal way to watch a test fail.** Measured on a project running the generated workflow:
+convergence and the rework it ordered cost one slice 12.9 times its implementation, because the stage's exit
+condition was the judgement of the model being looped and nothing bounded it; a `/drive` on a branch
+fifty-seven commits behind trunk wrote a second example map for a slice that had shipped, because every
+artifact the ladder reads is a property of the commit it is on; and two delegates in a row reached for
+`git stash` and a copied-aside backup, both forbidden, because they needed to observe a failure without
+dirtying the tree and the safety page forbade the routes without naming one. Now the convergence rung stops
+at two passes by default and appends what is still open as Phase 4 tasks, only a `CRITICAL` or `HIGH` finding
+re-opens it and only a `CRITICAL` re-opens it past the bound, the first pass is handed every abstraction level to account for, the tree is checked clean after
+every pass including a stopped one, and a stopped pass's last line is a lead to re-run rather than a finding
+to file. The entry-stage evidence names the branch, its head and its distance from trunk, and an unreachable
+remote reads as *could not verify*, never as *current* or as every slice unclaimed. The implement brief and
+the safety page name the sanctioned move — change the production file, run the test, restore that one path —
+and ask whether each RED was observed before the implementation existed. A brief may name where a fact lives
+without asserting what it says, the host derives concurrency from disjoint manifests rather than waiting for a
+`[P]` the task list only applies to production-code contention, and `./init` says to restart the session
+before delegating, since a harness reads its agent types once.

{slipwai-1.0.1.dev7 → slipwai-1.0.1.dev10}/src/slipwai/project/agents.py

@@ -20,6 +20,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 
 from ..layout import AT_ROOT, Layout
+from .converge_stage import levels
 from .stage_models import AGENT, ANY, MANIFEST, NO_STAGE, STAGES
 
 # Where the canonical types live, beside `skills/` and `commands/`.
@@ -120,6 +121,17 @@ The task, its contract and the files you may read and write are in the brief; no
 repository is yours to edit, including `tasks.md` — report which task you finished and the session that
 delegated you ticks the checkbox, because concurrent siblings would otherwise all write that one file.
 
+**RED is observed before the code that satisfies it exists, and the report says so.** A failure reconstructed
+afterwards — implement, undo the implementation to watch the test fail, restore — proves the test fails without
+the change and not that it was written independently of it, and the two are indistinguishable in the diff.
+Where every symbol the test names already exists from earlier increments there is nothing to write first: the
+RED is the new test run against the unchanged code. To check that an assertion has teeth — a test that passed
+on first run, an example you want to see fail for its own reason — change the production file, run the test,
+and restore that one file with `git checkout -- <exact path>`. Never `git stash`: it is a whole-tree operation
+and sweeps up the uncommitted work of a sibling writing beside you. Never copy the file aside as a backup. The
+safety page forbids both, and this is the sanctioned route it implies. Say in your report whether each RED was
+an assertion failure rather than a build failure, and whether it was observed before the implementation existed.
+
 Return the task you finished, the tests you added with their names, the commands you ran and their results,
 and anything you had to leave undone. A task that cannot be done as specified is reported, not reinterpreted:
 say what the plan assumed and what the code actually is.""",
@@ -131,10 +143,25 @@ The verdict names each principle the diff touches — a MUST about money, time,
 file and line that satisfies it. "No constitution obligation unmet" as one sentence is not a verdict: a slice
 has shipped a float in a monetary column under exactly that sentence.
 
+Account for every level in one pass — {levels()} — saying for
+each what the diff proves there and what it does not, so the session that delegated you is not sent back for
+a pass per level. Grade every task you append
+`CRITICAL`, `HIGH`, `MEDIUM` or `LOW`: only the first two re-open the loop, and only a `CRITICAL` re-opens it
+past the ladder's bound, so the grade is a decision about what the slice may ship without, not a label. The
+brief names your budget; when you reach it, return what you have found marked incomplete rather than
+continuing — an incomplete verdict with three findings is worth more than a complete one nobody waited for.
+
+Where you prove a finding by changing the code and watching the suite, you own leaving the tree clean on every
+exit path, including the one where you are stopped: make a branch or a commit before your first mutation so an
+abandoned pass is recoverable by construction, restore each file with `git checkout -- <exact path>` before
+moving to the next, and never `git stash` or copy a file aside. A pass stopped mid-mutation left two arguments
+swapped in the working tree the demo was about to run from.
+
 Your one write is new tasks, which is what makes converge safe to repeat, plus whatever the verdict itself
 requires under the manifest. Do not run the full `{layout.make} verify`: that gate runs after demo
 acceptance, immediately before the implementation is pushed. Return the verdict, the tasks you appended and
-the evidence for each, so the session that delegated you can re-run this stage until it reports converged.""",
+the evidence for each, so the session that delegated you can re-run this stage until it reports converged
+or the ladder's bound is reached.""",
 
         "drive-gaps": """You read, and you report what is missing. You change nothing.
 

{slipwai-1.0.1.dev7 → slipwai-1.0.1.dev10}/src/slipwai/project/commands.py

@@ -9,6 +9,7 @@ from ..targets import managed
 from .add_commands import add_command_files
 from .adversary import adversary_command
 from .benchmark import benchmark_command, what_each_stage_costs
+from .converge_stage import convergence_stage
 from .demo_stop import demo_stop
 from .drive_adoption import adoption_ladder
 from .existing import release_stage
@@ -124,25 +125,7 @@ def drive_command(
             if web
             else ""
         ),
-        """**Convergence** — `tasks.md` records a converged verdict for the current commit and has no
-   unchecked convergence task. Otherwise run the installed Spec Kit converge command, implement whatever it
-   appends, and repeat until it reports converged; record that verdict under a `## Convergence` heading so
-   this stage is not re-run, then `/gaps` over the slice diff. The verdict names each constitution principle
-   the diff touches — a MUST about money, time, identity, a boundary — with the file and line that satisfies
-   it; "no constitution obligation unmet" as one sentence is not a verdict, and a slice has shipped a float in
-   a monetary column under exactly that sentence. Converge is append-only — its one write is
-   new tasks — so repeating it is safe. A Spec Kit install with no converge command is a skip with a stated
-   reason, not a stop.
-
-   **Each appended task closes the class, not the instance it was found at.** Where a finding sits on a
-   repeated surface — a field in a parser, a row in a route table, one screen of a pair, one array cap in a
-   decoder, one column of a field table — the task's GREEN names the sweep rather than the example ("every
-   field this parser validates", "both screens of the crossing", "every array this decoder bounds"), and the
-   verdict records the sweep that was performed and what it found. A pass that validates one field and leaves
-   its neighbour is a pass the next one repeats: six of them closing a sibling each is the same work as one
-   closing the surface, at six times the price, and it is what writing the task as the example produces.
-   Where the sweep is genuinely larger than the slice, say so in the verdict and leave a task naming the
-   rest — that is a scope decision recorded, not a sibling found again next pass.""",
+        convergence_stage(),
         """**Demo** — the actor-visible path is ready to show.""",
     ]
     if adoption is not None:
@@ -165,6 +148,17 @@ is the first one whose artifact is missing, empty, or still a placeholder — **
 of the slice loop**. State the entry stage and the evidence that selected it before changing anything, then
 run that stage and every stage after it. Never rerun a completed stage merely to check.
 
+**The checkout goes stale the way conversation memory does, so check the branch before the artifacts.**
+Every signal the ladder reads — a slice's `status`, whether `examples.md` or `tasks.md` exists, the slice
+graph — is a property of this commit, and a branch behind trunk reads exactly like a project where the work
+was never done: a `/drive` fifty-seven commits behind wrote a second example map for a slice that had
+shipped. So fetch and compare first — `git fetch`, then `git log --oneline HEAD..@{{u}}`, or against
+`origin/main` where the branch has no upstream. Behind by anything, stop and say so rather than deriving:
+the artifacts about to be read are not the project's current ones. The evidence line names the branch, its
+head and its distance from trunk in the same breath as the stage. Where the fetch could not run — no remote,
+or a remote this environment cannot reach — the line says *could not verify this checkout is current*, and
+that never reads as *current*.
+
 {ladder}
 
 Being invoked before any of this exists is a valid start, not an error: it means the entry stage is near the

slipwai-1.0.1.dev10/src/slipwai/project/converge_stage.py

@@ -0,0 +1,75 @@
+"""The convergence rung of `commands/drive.md`: the one stage whose exit condition is a judgement, and the
+bounds that keep it a stage rather than a loop.
+
+Its own module for the reason `demo_stop.py` is: the text has grown by evidence, and each addition is a slice
+that paid for its absence. The class-not-instance rule came from six passes closing a sibling each. The
+bound, the severity floor and the level list came from a slice whose convergence and rework cost 12.9 times
+its implementation — every finding real, one pass running 5h47m unbounded, four passes each looking one
+abstraction level further out than the last, six MEDIUM tasks each re-opening the loop. The clean-tree check
+and the lead-not-finding rule came from a pass stopped mid-mutation: the tree was left mutated with nothing
+announcing it, and the pass's last line became a HIGH task and a waiver before anyone re-ran it and found
+that the mutant dies.
+"""
+from __future__ import annotations
+
+# Passes after which the loop stops by default and what is still open goes to Phase 4. One pass finds the
+# work and one confirms it closed; a third is a decision somebody takes, not what the wording produces.
+PASSES = "two"
+# Every level a first pass is asked to account for, so the follow-on passes that would each look one level
+# further out are one pass. Named once, so the ladder and the converge brief cannot list them differently.
+LEVELS = ("domain", "use case", "delivery adapter", "screen", "published contract")
+
+
+def levels() -> str:
+    return ", ".join(LEVELS)
+
+
+def convergence_stage() -> str:
+    """The `**Convergence**` rung, as one item of the ladder's numbered list (three-space continuation)."""
+    return f"""**Convergence** — `tasks.md` records a converged verdict for the current commit and has no
+   unchecked convergence task. Otherwise run the installed Spec Kit converge command, implement whatever it
+   appends, and repeat — until it reports converged, or until the loop reaches its bound, whichever is first.
+   Record that verdict under a `## Convergence` heading so this stage is not re-run, then `/gaps` over the
+   slice diff. The verdict names each constitution principle the diff touches — a MUST about money, time,
+   identity, a boundary — with the file and line that satisfies it; "no constitution obligation unmet" as one
+   sentence is not a verdict, and a slice has shipped a float in a monetary column under exactly that
+   sentence. Converge is append-only — its one write is new tasks — so repeating it is safe. A Spec Kit
+   install with no converge command is a skip with a stated reason, not a stop.
+
+   **The loop has a bound, because its exit condition is the judgement of the thing being looped.** Every
+   other rung ends on something an outside reader can evaluate — a file exists, tasks are ticked, a gate is
+   green. This one ends on the opinion of a fresh strong model asked to find what is missing, and asked that,
+   it will find something: at any level there is a level further out. So: at most {PASSES} passes by default —
+   one to find the work, one to confirm it closed. A pass beyond that is a decision this session takes and
+   says why, never what this wording produces — with one exception the bound does not hold against: **an
+   open `CRITICAL` finding re-opens the loop however many passes have run**, because a slice does not go to
+   its demo carrying one. When the bound is reached, whatever is still open and not `CRITICAL` is appended
+   as Phase 4 tasks, the verdict says the loop stopped at its bound, and the slice goes to its demo: the
+   actor's feedback is better evidence about whether the slice is right than a third reading of the same
+   diff. Only a `CRITICAL` or `HIGH` finding re-opens the loop at all, and only a `CRITICAL` re-opens it past
+   the bound; grade every appended task, and a `MEDIUM` or `LOW` rides along with the next pass or lands in
+   Phase 4 rather than costing a pass-and-fix cycle of its own. Hand the **first** pass the level list and ask it to account for each —
+   {levels()} — because four passes on one slice each looked exactly one level further out than the
+   last, and asked for all of them at once they are one pass. Give each pass a stated budget in its brief and
+   take what it has found when it reaches it: an incomplete verdict with three findings is worth more than a
+   complete one nobody waited for.
+
+   **After every pass — including one that was stopped — the tree is clean before anything else runs.**
+   Converge proves a finding by mutating the code and restoring it, and a pass stopped mid-mutation leaves
+   the mutation in place with nothing announcing it; the next thing on this ladder is the demo, which would
+   show the actor the mutation. `git status` is two seconds against that. And **a finding from a pass that
+   did not finish is a lead, not a finding**: a stop notification's last line is a fragment of work in
+   progress, and what was in progress was checking. Re-run its reproduction before it is written into
+   `tasks.md`, a waiver or anything outside this session — one mutation, one test run, one restore — and
+   until then write it as *a stopped pass believed X; verify before acting*. One such line became a HIGH
+   task, a waiver and a published finding within the hour, and the mutant died when somebody re-ran it.
+
+   **Each appended task closes the class, not the instance it was found at.** Where a finding sits on a
+   repeated surface — a field in a parser, a row in a route table, one screen of a pair, one array cap in a
+   decoder, one column of a field table — the task's GREEN names the sweep rather than the example ("every
+   field this parser validates", "both screens of the crossing", "every array this decoder bounds"), and the
+   verdict records the sweep that was performed and what it found. A pass that validates one field and leaves
+   its neighbour is a pass the next one repeats: six of them closing a sibling each is the same work as one
+   closing the surface, at six times the price, and it is what writing the task as the example produces.
+   Where the sweep is genuinely larger than the slice, say so in the verdict and leave a task naming the
+   rest — that is a scope decision recorded, not a sibling found again next pass."""

{slipwai-1.0.1.dev7 → slipwai-1.0.1.dev10}/src/slipwai/project/demo_stop.py

@@ -14,7 +14,9 @@ def board_sources(event: bool) -> str:
     """Where the progress board is read from, per profile — shared with `/where-are-we`, which draws the same
     board between demos, so the two commands cannot name different artifacts."""
     claims = (
-        "and the forge's `slice/<id>` branches (`git ls-remote --heads origin 'slice/*'`), which are the claims"
+        "and the forge's `slice/<id>` branches (`git ls-remote --heads origin 'slice/*'`), which are the claims —"
+        " read, never assumed: where that command fails the board says the claims could not be read, and"
+        " shows no slice as unclaimed on the strength of a failed read"
     )
     sources = (
         "the ordered split and its `## Slice graph`, the register at `specs/<feature>/slices/README.md` — a row\n"

{slipwai-1.0.1.dev7 → slipwai-1.0.1.dev10}/src/slipwai/project/docs.py

@@ -254,7 +254,7 @@ For one small vertical slice:
 3. Create or resume `plan.md` and `tasks.md` with the Spec Kit commands installed by `./init`.
 4. Implement each task RED-GREEN-REFACTOR, keeping `make verify` green.
 5. Run the installed Spec Kit converge command, implement whatever it appends, and repeat until it reports
-   converged; then `/gaps` over the slice diff.
+   converged or reaches its bound; then `/gaps` over the slice diff.
 6. Demonstrate the actor-visible path and pause for feedback.
 7. After acceptance, run `/mutation` and `make verify` — and `/adversary` first, when the slice changed
    attack surface or closed the split.
@@ -270,7 +270,7 @@ there is a target — before the first principle is written. It applies from the
 feature under `specs/` whether or not the constitution was touched.
 
 Three stages in the loop are deliberately not the shape they look like. **Converge** is append-only — its
-only write is new tasks — so it is safe to repeat until it reports converged, and it is what makes the demo
+only write is new tasks — so it is safe to repeat until it reports converged or reaches its bound, and it is what makes the demo
 worth showing. The **second `/gaps`** runs after that verdict rather than before it, because ahead of
 converge every unbuilt task reads as a gap and buries the findings that need judgement. **`/adversary`** is
 an end-of-phase pass rather than a per-slice one: `commands/adversary.md` runs it when the diff changed

{slipwai-1.0.1.dev7 → slipwai-1.0.1.dev10}/src/slipwai/project/guidance.py

@@ -292,7 +292,7 @@ type: a brief adds only its task-specific contract and file manifest, and restat
 Use `/drive` to resume from the first missing artifact or unchecked task, whether that artifact is the
 constitution, the product specification, the split, or the slice's own tasks. Work through specification,
 `/gaps` over the slice's acceptance criteria, plan, tasks, RED-GREEN-REFACTOR implementation, the installed
-Spec Kit converge command until it reports converged, `/gaps` over the slice diff, and an actor-visible
+Spec Kit converge command until it reports converged or reaches its bound, `/gaps` over the slice diff, and an actor-visible
 demo. Pause at the demo for feedback; after acceptance run `/adversary` when the slice changed attack
 surface or closed the split — `commands/adversary.md` makes and records that decision — then `/mutation` and
 `make verify`. Stop earlier only for a product decision or unavailable external input.
@@ -308,7 +308,7 @@ extension hook is not a gate.
 
 Continue until the actor-visible path is ready for a demo, a product decision or unavailable external input
 blocks progress, or the ordered split is exhausted. Before the demo, run the installed Spec Kit converge
-command until it reports converged and `/gaps` over the slice diff. At the demo, pause for feedback. On
+command until it reports converged or reaches its bound, and `/gaps` over the slice diff. At the demo, pause for feedback. On
 acceptance, harden and finish the slice — `/adversary` when the slice changed attack surface or closed the
 split, then `/mutation` and `make verify` — then continue to the ready slices (not done, every `depends_on` done): every unclaimed one whose contract is settled runs concurrently, one delegate per slice on a `slice/<id>` branch, merged in split order (`commands/drive.md`, *Running ready slices concurrently*); where the harness cannot delegate, the earliest in split order, naming the rest.
 

{slipwai-1.0.1.dev7 → slipwai-1.0.1.dev10}/src/slipwai/project/parallel_slices.py

@@ -91,7 +91,10 @@ Rejected means another session got there first: skip to the next unclaimed ready
 never error. Read the claims back with `git ls-remote --heads origin 'slice/*'`; the board shows 🔀
 *Ready* split into *claimed by* and *unclaimed*. A claim whose last commit is days old is reported as
 stale, never silently taken — its owner may be mid-slice. Without a remote, the local branch is the claim,
-and say so.
+and say so. A remote that is configured and cannot be reached is the other case, and it looks like success:
+`ls-remote` fails, every slice reads as unclaimed, and that is exactly the answer that lets two sessions take
+one slice. A failed read is reported as *claims could not be read*, never as *unclaimed*, and no slice is
+claimed on the strength of it.
 
 **Each slice has its own worktree and one delegate.** For every unclaimed ready slice whose contract is
 settled, in the same turn: claim it, give it a worktree (`git worktree add ../<project>-<id> slice/<id>`;

{slipwai-1.0.1.dev7 → slipwai-1.0.1.dev10}/src/slipwai/project/stage_models.py

@@ -169,7 +169,13 @@ worktree to choose a model for each stage it then runs.
 
 Delegate to the type by name. The type is the standing brief, so the call adds only the task, its contract and
 the file manifest — it never describes the role again or restates the scope, and it does not give the delegate
-conclusions. The page each type is written on is `docs/delegated-agent-safety.md`, the standing boundary every
+conclusions. It may give it a map: which precedent to copy, which decision in `research.md` governs, which
+helper already exists — a file and a section, which the delegate then opens and reads for itself. Naming where
+a fact lives is a pointer and costs a sentence; asserting what it says is a conclusion, and a brief that asked
+the delegate to read a decision itself and report what it says has caught what a brief that summarised it got
+wrong. Where a brief offers a delegate more than one way of working, every permission is written into each
+mode that has it, even at the price of a repeated paragraph: a fresh delegate reads a silence conservatively,
+and the conservative reading is the expensive one. The page each type is written on is `docs/delegated-agent-safety.md`, the standing boundary every
 delegation is held to: reference it, restate none of it (`AGENTS.md`, *Delegated agents*).
 
 **A delegate does not inherit this session's code-index connection.** Where `AGENTS.md` carries the
@@ -198,7 +204,11 @@ A stage is not always one delegate. Before delegating implementation, read `task
 its *Parallel opportunities* section: the tasks command writes both, and they are the plan for what may run
 alongside what — written by one half of this workflow to be read here, not decoration. Every unchecked `[P]`
 task whose files are disjoint from the batch already running is a concurrent sibling, delegated in the same turn
-with a manifest of its own; a task with no marker, or whose files overlap a sibling's, waits its turn. What the
+with a manifest of its own — and so is a task with no marker whose manifest shares no file with the batch. The
+marker is the tasks command's reading of production-code contention, and it under-reports: one slice's list
+marked one pair concurrent, said of the rest "none, by construction", and left two pairs that shared no file
+to run in sequence. The manifests are the artifact; read them, and let only an overlap with a running
+sibling's files, or what the section rules out, keep a task waiting. What the
 section rules out stays sequential whatever the markers seem to allow — a RED-GREEN-REFACTOR increment starts
 from a green, committed suite, and two of them at once is the batched-tests anti-pattern with a `[P]` on it.
 The siblings are `drive-implement` delegates, and that type is where the rule they cannot infer for
@@ -207,7 +217,9 @@ otherwise contend for, so each reports which task it finished and this session t
 
 When several delegates form one batch, report once when the batch completes rather than once per delegate.
 Verify their claims by spot-checking the recorded reproduction or RED evidence; do not repeat each complete
-investigation in the host context. Do not re-investigate. An adversary pass is the same kind of batch:
+investigation in the host context. Do not re-investigate. A delegate that was stopped has filed nothing:
+everything in its stop notification is a lead, never a result, and a lead is re-run before it is written
+anywhere outside this session. An adversary pass is the same kind of batch:
 disjoint-manifest seams of one pass are concurrent `drive-adversary` siblings in one turn, and the host
 writes the log after the batch rather than re-attacking. It records the type and the explicit model that
 ran each seam in `specs/<feature>/adversary-log.md`, especially when seams use different models.

slipwai-1.0.1.dev7/VERSION

@@ -1 +0,0 @@
-1.0.1.dev7