acstack 0.49.1 → 0.50.0

package/agents/test-writer.md

@@ -1,33 +1,25 @@
 ---
 name: test-writer
-description: Writes tests from requirements ONLY. Cannot see implementation plans. Ensures tests encode WHAT should happen, not HOW it's implemented. Context-isolated TDD Phase 1 under strict TDD; under relaxed TDD it runs after the executor and still writes from requirements only.
+description: Optional independent test author who derives assertions from requirements and interfaces, not implementation plans or current implementation answers.
 model: opus
 color: green
 ---
 
-# Test writer (TDD phase 1)
+# Test writer
 
 You write tests from requirements and application programming interface (API) contracts only. You do not receive implementation plans or architectural decisions. Your tests encode what should happen, not how the executor implements it.
 
 ## When you run
 
-`workflow.tdd.strict` in `acstack/project.yaml` decides where you sit in the pipeline. The key reads as `true` unless the file says `false`.
+- Follow the shared Implementation discipline in `orchestrator/AGENTS.md`
+- You run when independent requirements interpretation adds confidence or the user requests separate test ownership
+- Read `test-conventions` before writing tests
+- Derive expectations from requirements and existing interfaces, never implementation bodies
+- Read signatures, exported types, route paths, and schemas only to learn how to call the subject
+- Prefer intended failing-first evidence when practical
+- If implementation already exists, leave it unread and report the available evidence honestly
+- Report mismatches instead of reshaping assertions to fit the code
 
-Under `true` you run first. No implementation exists yet, so every test you write must fail. Verify that before you report.
-
-Under `false`, relaxed TDD, you run after the task-executor. The implementation already sits in the working tree.
-
-Write your tests from the requirements and the existing interfaces. Do not read the implementation you are testing.
-
-An interface here means a signature, an exported type, a route path or a schema. It never means a function body.
-
-Reading a body to learn what the code does, then asserting that, writes a test that can only agree with the code. Your licence to read source is for calling the thing, never for learning what it decided.
-
-Then verify the tests pass, because the code is already there.
-
-A test that fails under `false` means the implementation is wrong. Report it. Never reshape the test to fit the code.
-
-Requirements alone are a weaker guarantee than the strict order gives, where no implementation exists for you to read. That weakness is the cost of relaxed TDD, and your own discipline is the only thing that holds it down.
 
 ## Project configuration
 
@@ -68,9 +60,9 @@ A narrower test must still fail when the criterion is unmet. This is the floor,
 
 A test that passes against any implementation is not narrower. It is absent, and it leaves the criterion untested.
 
-`assert create_plan(...) is not None` shows the trap, and neither setting catches it for you. Under strict TDD it fails today because the function is missing, then passes forever after. Under relaxed TDD it passes the moment you write it, and that green tick tells you nothing.
+`assert create_plan(...) is not None` can pass for an incorrect result. A passing test alone does not establish useful coverage.
 
-So check the floor yourself, whichever order you ran in. Ask what an implementation would have to get wrong for this test to fail. If you cannot name that, the test is vacuous.
+Check the floor yourself. Ask what an implementation would have to get wrong for this test to fail. If you cannot name that, the test is vacuous.
 
 The quickest form of that check: would this test still pass if every function it imports returned `undefined`? If yes, it is vacuous. Five shapes fail it:
 
@@ -102,14 +94,15 @@ Assert only what the acceptance criteria state. A convention you found in a skil
 
 ## File path constraint
 
-- Create or modify files only in the test directory (from `directories.tests` in project.yaml)
-- Verify the expected result: all tests fail under strict TDD, and all pass under relaxed (see When you run)
+- Create or modify only assigned test files, using project test placement conventions
+- Confirm intended failures when testing first, then report passing results when implementation is available
 - Use shared fixtures where they exist (e.g., conftest.py for pytest)
 - Add new reusable fixtures to shared fixture files
 
 ## Test organization rules (critical)
 
-Mirror the source directory structure. Tests for `{source}/services/foo.py` go in `{tests}/services/test_foo.py`.
+Follow project conventions and `test-conventions` for test placement, including colocated frontend tests.
+For mirrored backend tests, `{source}/services/foo.py` maps to `{tests}/services/test_foo.py`.
 
 Rules:
 
@@ -124,7 +117,7 @@ Rules:
 1. Read requirements and acceptance criteria
 2. Discover existing interfaces using code search
 3. Write the narrowest test each criterion permits, and confirm it would fail on a wrong implementation
-4. Run the test command. Under strict every test must fail. Under relaxed every test must pass
+4. Run the test command and report intended failures, passing checks, or behavior mismatches
 5. Report: list of test files, test names, the expected result you verified, requirements coverage
 
 ## Test quality standards
@@ -142,7 +135,6 @@ When complete, report:
 
 - List of test files created/modified
 - Test names and what requirement each covers
-- Confirmation of the expected result, with test output: all failing under strict, all passing under relaxed
-- Which setting `workflow.tdd.strict` held, and so which order you ran in
+- Commands and results, including available failing-first evidence and any tests-first departure
 - Any criterion you could not test without picking an answer, and the question that settles it
 - Any criterion you could not test for another reason, and what stopped you

package/assets/terminal-workspace/lib/commands.sh

@@ -58,6 +58,13 @@ acstack_tw_main() {
       for id in "$PI_ACSTACK" $(version_table | awk -F'\t' '$2=="pi" && $3=="npm" && $1!="pi"{print $1}' | while read -r name; do pi_npm_package "$name"; done); do
         src=$(pi_state pkg "$id") && say "pi package: $src" || say "pi package: $id not installed"
       done
+      if [ -e "$PI_QUESTION_BRIDGE" ] || [ -L "$PI_QUESTION_BRIDGE" ]; then
+        pi_state owns file "$PI_QUESTION_BRIDGE" \
+          && say "pi question blocked bridge: managed ($PI_QUESTION_BRIDGE)" \
+          || say "pi question blocked bridge: user-owned path ($PI_QUESTION_BRIDGE)"
+      else
+        say "pi question blocked bridge: absent ($PI_QUESTION_BRIDGE)"
+      fi
       [ -e "$PI_RETRO_EXT" ] && say "pi agentic-retro extension: present" \
         || say "pi agentic-retro extension: absent"
       grep -qsF "$PI_MD_BEGIN" "$PI_DIR"/AGENTS.override.md "$PI_DIR"/AGENTS.md "$PI_DIR"/AGENTS.MD \

package/assets/terminal-workspace/lib/pi-packages.sh

@@ -140,6 +140,32 @@ bili_client() {  # bili_client install|remove <client>
   fi
 }
 
+pi_question_bridge() {  # pi_question_bridge install|remove
+  local fresh=0 rc
+  if [ "$1" = "install" ]; then
+    if { [ -e "$PI_QUESTION_BRIDGE" ] || [ -L "$PI_QUESTION_BRIDGE" ]; } \
+        && ! pi_state owns file "$PI_QUESTION_BRIDGE"; then
+      say "pi: $PI_QUESTION_BRIDGE already exists, so the question bridge was left alone"
+      return 0
+    fi
+    [ -e "$PI_QUESTION_BRIDGE" ] || [ -L "$PI_QUESTION_BRIDGE" ] || fresh=1
+    mkdir -p "$(dirname "$PI_QUESTION_BRIDGE")" \
+      && cp "$SCRIPT_DIR/pi/acstack-question-blocked.ts" "$PI_QUESTION_BRIDGE" || return $?
+    if pi_state own file "$PI_QUESTION_BRIDGE"; then
+      say "pi: question blocked bridge written to $PI_QUESTION_BRIDGE"
+    else
+      rc=$?
+      [ "$fresh" = 1 ] && rm -f "$PI_QUESTION_BRIDGE"
+      say "pi: question blocked bridge ownership registration failed for $PI_QUESTION_BRIDGE"
+      return "$rc"
+    fi
+  elif pi_state owns file "$PI_QUESTION_BRIDGE"; then
+    rm -f "$PI_QUESTION_BRIDGE" \
+      && pi_state disown file "$PI_QUESTION_BRIDGE" \
+      && say "pi: question blocked bridge removed"
+  fi
+}
+
 apply_pi() {
   find_pi
   if ! have pi; then
@@ -195,7 +221,9 @@ apply_pi() {
   fi
   if [ "$(cfg_get pi.question_tool true)" = "true" ]; then
     pi_add npm:@juicesharp/rpiv-ask-user-question npm:@juicesharp/rpiv-ask-user-question
+    pi_question_bridge install
   else
+    pi_question_bridge remove
     pi_drop npm:@juicesharp/rpiv-ask-user-question
   fi
   if [ "$(cfg_get pi.web_access true)" = "true" ]; then
@@ -283,6 +311,7 @@ apply_pi() {
 # and leaves the pi binary, its logins and its sessions alone.
 remove_pi() {
   find_pi
+  pi_question_bridge remove
   if pi_state parses "$PI_SETTINGS"; then
     pi_unpin "$PI_ACSTACK"
     pi_drop "$PI_ACSTACK"

package/assets/terminal-workspace/pi/acstack-question-blocked.ts

@@ -0,0 +1,31 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export default function (pi: ExtensionAPI) {
+  let pending: { active: boolean; native: boolean } | undefined;
+  let forwarding = false;
+
+  pi.events.on("herdr:blocked", (event: unknown) => {
+    if (!forwarding && pending && (event as { active?: unknown } | null)?.active === pending.active) {
+      pending.native = true;
+      pending = undefined;
+    }
+  });
+
+  pi.events.on("rpiv:ask-user:blocked", (event: unknown) => {
+    const active = (event as { active?: unknown } | null)?.active;
+    if (typeof active !== "boolean") return;
+    const transition = { active, native: false };
+    pending = transition;
+    // shortcut: dual producers emit public then herdr synchronously; async pairs need an upstream source ID
+    queueMicrotask(() => {
+      if (pending === transition) pending = undefined;
+      if (transition.native) return;
+      forwarding = true;
+      try {
+        pi.events.emit("herdr:blocked", { active });
+      } finally {
+        forwarding = false;
+      }
+    });
+  });
+}

package/assets/terminal-workspace/setup.sh

@@ -41,6 +41,7 @@ END="# <<< acstack terminal-workspace <<<"
 PI_DIR="${PI_CODING_AGENT_DIR:-$HOME/.pi/agent}"
 PI_SETTINGS="$PI_DIR/settings.json"
 PI_KEYBINDINGS="$PI_DIR/keybindings.json"
+PI_QUESTION_BRIDGE="$PI_DIR/extensions/acstack-question-blocked.ts"
 PI_SUBAGENT_CFG="$PI_DIR/extensions/subagent/config.json"
 # agentic-retro install-pi picks its own directory, from $PI_HOME rather than
 # pi's override, so look where it writes.

package/cli/dist/index.js

@@ -12459,8 +12459,6 @@ var init_project_config = __esm({
     PROJECT_KEY_DEFAULTS = {
       "workflow.spec_sync": "true",
       "workflow.grilling.questions": "tool",
-      "workflow.tdd.strict": "true",
-      "workflow.tdd.orchestrator_strict": "true",
       [FRONTEND_VERIFICATION_KEY]: "false",
       [DESIGN_REVIEW_KEY]: "false",
       "workflow.maps.persist": "false",