feat: maximize project-context.md across all pipeline stages

Core:
- Add parse_project_context module (ProjectContext, GuardCommands structs)
- Parse yaml blocks for Guard Commands and File Conventions
- infer_domain() matches file paths to domains via conventions
- conflicts_with_non_goals() keyword matching
- flowctl project-context show/domain commands

Guard integration:
- Guard reads Guard Commands from project-context as highest priority
- Falls back to stack config → auto-detection

Init generation:
- Auto-detect guard commands (test/lint/typecheck/format per stack)
- Auto-detect file conventions (scan actual directories)
- Auto-detect critical rules (unsafe_code, strict TS, CI)
- Refactored into detect_stack/generate_guard_commands/generate_file_conventions/detect_rules

Skills/prompts updated (7 files):
- brainstorm: reads Non-Goals + Architecture Decisions
- plan: reads Non-Goals, File Conventions, Architecture Decisions
- plan_review: verifies against Non-Goals
- close: Non-Goals compliance in pre-launch checklist
- Edge Case Hunter: checks Critical Rules violations
- Acceptance Auditor: checks Non-Goals compliance
- Worker spawn: includes Non-Goals + Critical Rules in prompt

8 new tests, 359 total pass.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: z23cc

bin/flowctl

@@ -14,6 +14,10 @@ $FLOWCTL config get scouts.github --json
 $FLOWCTL stack show --json
 ```
 
+## Read Project Context
+
+Read `.flow/project-context.md` if it exists. Use Non-Goals to scope out excluded approaches. Use File Conventions to auto-assign task domains. Use Architecture Decisions to avoid proposing alternatives to settled choices.
+
 ## Check Architecture Invariants
 
 ```bash

codex/skills/flow-code-plan/steps/step-02-research.md

@@ -77,6 +77,10 @@ Determine the RP_CONTEXT tier (check in order, first match wins):
    - **Tier 2 (CLI)**: `which rp-cli >/dev/null 2>&1` succeeds -> `RP_CONTEXT=cli`
    - **Tier 3 (fallback)**: Neither available -> `RP_CONTEXT=none`
 
+## Read Project Context for Workers
+
+If `.flow/project-context.md` exists, read the Non-Goals and Critical Implementation Rules sections. Include these in the worker prompt so workers don't violate constraints.
+
 ## Worker Prompt Generation
 
 Use `flowctl worker-prompt --bootstrap` to generate a minimal bootstrap prompt for each worker. This outputs a ~200 token prompt that instructs the worker to call `worker-phase next` in a loop, fetching full phase instructions on demand.
@@ -110,6 +114,8 @@ Agent({
     RP_CONTEXT: $RP_CONTEXT
     TEAM_MODE: true
     OWNED_FILES: <comma-separated file list from Step 6>
+    PROJECT_CONTEXT_NON_GOALS: <Non-Goals from .flow/project-context.md if exists>
+    PROJECT_CONTEXT_CRITICAL_RULES: <Critical Implementation Rules from .flow/project-context.md if exists>
   "
 })
 ```

codex/skills/flow-code-work/steps/step-04-spawn-workers.md

@@ -13,6 +13,7 @@ use serde_json::json;
 
 use crate::output::{error_exit, json_output, pretty_output};
 
+use flowctl_core::project_context::ProjectContext;
 use flowctl_core::types::CONFIG_FILE;
 
 use super::{deep_merge, get_default_config, get_flow_dir};
@@ -337,10 +338,43 @@ pub fn cmd_guard(json_mode: bool, layer: String) {
         get_default_config()
     };
 
+    // ── Priority chain: project-context → stack config → auto-detection ──
+    // Try project-context.md first (highest priority).
+    let pc = ProjectContext::load(&flow_dir);
+    let pc_commands = pc.as_ref().map(|ctx| {
+        let gc = &ctx.guard_commands;
+        let mut cmds: Vec<(String, String, String)> = Vec::new();
+        let layer_name = "project".to_string();
+        if let Some(ref cmd) = gc.test {
+            if !cmd.is_empty() && (layer == "all" || layer == "project") {
+                cmds.push((layer_name.clone(), "test".to_string(), cmd.clone()));
+            }
+        }
+        if let Some(ref cmd) = gc.lint {
+            if !cmd.is_empty() && (layer == "all" || layer == "project") {
+                cmds.push((layer_name.clone(), "lint".to_string(), cmd.clone()));
+            }
+        }
+        if let Some(ref cmd) = gc.typecheck {
+            if !cmd.is_empty() && (layer == "all" || layer == "project") {
+                cmds.push((layer_name.clone(), "typecheck".to_string(), cmd.clone()));
+            }
+        }
+        if let Some(ref cmd) = gc.format_check {
+            if !cmd.is_empty() && (layer == "all" || layer == "project") {
+                cmds.push((layer_name.clone(), "format_check".to_string(), cmd.clone()));
+            }
+        }
+        cmds
+    });
+
+    // Use project-context commands if any are defined; otherwise fall back to stack config.
+    let use_project_context = pc_commands.as_ref().is_some_and(|c| !c.is_empty());
+
     let stack = config.get("stack").cloned().unwrap_or(json!({}));
     let stack_obj = stack.as_object();
 
-    if stack_obj.is_none() || stack_obj.unwrap().is_empty() {
+    if !use_project_context && (stack_obj.is_none() || stack_obj.unwrap().is_empty()) {
         if json_mode {
             json_output(json!({
                 "results": [],
@@ -355,20 +389,24 @@ pub fn cmd_guard(json_mode: bool, layer: String) {
     let cmd_types = ["test", "lint", "typecheck"];
     let mut commands: Vec<(String, String, String)> = Vec::new(); // (layer_name, type, cmd)
 
-    for (layer_name, layer_conf) in stack_obj.unwrap() {
-        if layer != "all" && layer_name != &layer {
-            continue;
-        }
-        if let Some(layer_obj) = layer_conf.as_object() {
-            for ct in &cmd_types {
-                if let Some(cmd_val) = layer_obj.get(*ct) {
-                    if let Some(cmd_str) = cmd_val.as_str() {
-                        if !cmd_str.is_empty() {
-                            commands.push((
-                                layer_name.clone(),
-                                ct.to_string(),
-                                cmd_str.to_string(),
-                            ));
+    if use_project_context {
+        commands = pc_commands.unwrap();
+    } else {
+        for (layer_name, layer_conf) in stack_obj.unwrap() {
+            if layer != "all" && layer_name != &layer {
+                continue;
+            }
+            if let Some(layer_obj) = layer_conf.as_object() {
+                for ct in &cmd_types {
+                    if let Some(cmd_val) = layer_obj.get(*ct) {
+                        if let Some(cmd_str) = cmd_val.as_str() {
+                            if !cmd_str.is_empty() {
+                                commands.push((
+                                    layer_name.clone(),
+                                    ct.to_string(),
+                                    cmd_str.to_string(),
+                                ));
+                            }
                         }
                     }
                 }