@event4u/agent-config 9.1.0 → 9.3.0

package/src/scripts/hook_manifest.yaml

@@ -145,6 +145,17 @@ concerns:
     script: src/scripts/team_review_gate_hook.ts
     args: []
     fail_closed: false
+  # Reply-shape backstop for the direct-answers rule (reply-close): a PR
+  # created THIS turn must end the reply as the literal last raw URL. This
+  # PostToolUse hook fires right after a PR *create* (gh pr create, or a
+  # github create-pull-request tool) that produced a `…/pull/<n>` URL, and
+  # WARNS in context (exit 2) so the reminder lands before the reply closes.
+  # Never blocks; unconditional (reinforces an always-on rule, fires only on
+  # the rare create event, so no settings gate). fail_closed: false.
+  pr-url-reminder:
+    script: src/scripts/pr_url_reminder_hook.ts
+    args: []
+    fail_closed: false
 
 platforms:
   augment:
@@ -152,7 +163,7 @@ platforms:
     session_end:      [chat-history]
     stop:             [chat-history, hot-context, verify-before-complete]
     pre_tool_use:     [block-no-verify, rtk-wrap, design-slop]
-    post_tool_use:    [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan]
+    post_tool_use:    [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan, pr-url-reminder]
 
   claude:
     session_start:    [chat-history, hot-context, first-run-gate, onboarding-gate, verify-before-complete, minimal-safe-diff, profile-staleness, wrapper-freshness, surface-probe]
@@ -160,7 +171,7 @@ platforms:
     stop:             [chat-history, hot-context, verify-before-complete, team-review-gate]
     user_prompt_submit: [chat-history, verify-before-complete, minimal-safe-diff]
     pre_tool_use:     [block-no-verify, rtk-wrap, design-slop]
-    post_tool_use:    [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan]
+    post_tool_use:    [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan, pr-url-reminder]
 
   # Cowork — the Claude desktop app's local-agent-mode runtime, built
   # on top of the Claude Code CLI. Same lifecycle vocabulary, same
@@ -182,7 +193,7 @@ platforms:
     stop:             [chat-history, hot-context, verify-before-complete]
     user_prompt_submit: [chat-history, verify-before-complete, minimal-safe-diff]
     pre_tool_use:     [block-no-verify, rtk-wrap, design-slop]
-    post_tool_use:    [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan]
+    post_tool_use:    [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan, pr-url-reminder]
 
   # Phase 7.5 — Cursor. `.cursor/hooks.json` (project) is read by the
   # IDE and CLI; `~/.cursor/hooks.json` (user) is opt-in via
@@ -196,7 +207,7 @@ platforms:
     session_end:        [chat-history]
     stop:               [chat-history, hot-context, verify-before-complete]
     user_prompt_submit: [chat-history, verify-before-complete, minimal-safe-diff]
-    post_tool_use:      [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan]
+    post_tool_use:      [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan, pr-url-reminder]
 
   # Phase 7.6 — Cline. Hooks live under `.clinerules/hooks/<HookName>`
   # (project, no file extension, must be executable per Cline docs) or
@@ -211,7 +222,7 @@ platforms:
     session_end:        [chat-history]
     stop:               [chat-history, hot-context, verify-before-complete]
     user_prompt_submit: [chat-history, verify-before-complete, minimal-safe-diff]
-    post_tool_use:      [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan]
+    post_tool_use:      [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan, pr-url-reminder]
 
   # Phase 7.7 — Windsurf (Cascade). Hooks live at `.windsurf/hooks.json`
   # (project) or `~/.codeium/windsurf/hooks.json` (user). Cascade has
@@ -245,7 +256,7 @@ platforms:
     session_end:        [chat-history]
     stop:               [chat-history, hot-context, verify-before-complete]
     user_prompt_submit: [chat-history, verify-before-complete, minimal-safe-diff]
-    post_tool_use:      [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan]
+    post_tool_use:      [chat-history, roadmap-progress, context-hygiene, verify-before-complete, minimal-safe-diff, injection-scan, pr-url-reminder]
 
   # Phase 7.9 — Copilot has no hook surface. Concerns route through
   # rule-only fallback; the dispatcher silently no-ops on --platform copilot.

package/src/scripts/install-hooks.sh

@@ -8,32 +8,47 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 # This installer lives at src/scripts/install-hooks.sh, so the repo root
 # (which owns .git/) is two levels up.
 PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
-HOOKS_DIR="$PROJECT_ROOT/.git/hooks"
+# Resolve the SHARED hooks dir via git so this also works from a linked worktree
+# (where $PROJECT_ROOT/.git is a file, not a dir, and a literal .git/hooks path
+# would break under `set -e`). --git-common-dir points at the main .git even from
+# a worktree; fall back to the literal path only outside a git repo.
+if COMMON_GIT_DIR="$(git -C "$PROJECT_ROOT" rev-parse --git-common-dir 2>/dev/null)"; then
+    case "$COMMON_GIT_DIR" in /*) : ;; *) COMMON_GIT_DIR="$PROJECT_ROOT/$COMMON_GIT_DIR" ;; esac
+    HOOKS_DIR="$COMMON_GIT_DIR/hooks"
+else
+    HOOKS_DIR="$PROJECT_ROOT/.git/hooks"
+fi
 
 mkdir -p "$HOOKS_DIR"
 
 cat > "$HOOKS_DIR/pre-push" << 'EOF'
 #!/usr/bin/env bash
-# Pre-push hook: verify dist/agent-src/ is in sync with .agent-src.uncondensed/
-# and that the canonical command count matches README + getting-started docs.
+# Pre-push hook: mirror the CI "Sync + Generate Tools Consistency" gate LOCALLY
+# so derived-output drift is caught BEFORE push, not in remote CI.
 #
-# The command-count gate exists because three consecutive PRs landed
-# post-CI count-drift fixes (e.g. f2fb0026 "bump command count
-# 101→103"). Catching the drift pre-push stops it from flooding remote
-# CI. Runtime ~0.1s.
+# History: the remote "Consistency" check failed in a large share of PRs because
+# the old hook only verified dist sync + the COMMAND count — it missed
+# guideline/skill/rule count drift and the generate-tools / router / corpus
+# outputs (e.g. a new guideline bumping the count in README + docs/architecture).
+# `task consistency` is the EXACT CI mirror (sync-check + sync-check-hashes +
+# sync + generate-tools + compile-router + compile-corpus + `git diff --quiet`),
+# so any derived-output drift blocks the push here. Runtime ~15-40s (it
+# regenerates the tool trees) — cheaper than a red CI run and a fixup re-push.
 
 fail=0
 
-echo "🔍 Checking dist/agent-src/ sync..."
-if ! ./scripts-run src/scripts/condense --check; then
-    echo "❌  dist/agent-src/ is out of sync. Run 'task sync' and condense changed .md files, then commit."
-    fail=1
-fi
-
-echo "🔍 Checking command count messaging..."
-if ! ./scripts-run src/scripts/check_command_count_messaging; then
-    echo "❌  Command-count drift in README / AGENTS.md / getting-started. Run 'task counts-update', stage the changes, then re-commit."
-    fail=1
+if ! command -v task >/dev/null 2>&1; then
+    echo "⚠️  'task' (go-task) not found — cannot run the consistency gate locally."
+    echo "    Install it (https://taskfile.dev) so pre-push can mirror the CI check;"
+    echo "    skipping the consistency check for this push."
+else
+    echo "🔍 Consistency — mirroring the CI 'Sync + Generate Tools Consistency' gate..."
+    if ! task consistency; then
+        echo "❌  Derived outputs drifted (counts / dist / generated tool trees / router / corpus)."
+        echo "    'task consistency' just regenerated them into your working tree —"
+        echo "    review + 'git add' the changes (or run 'task consistency-fix'), commit, then re-push."
+        fail=1
+    fi
 fi
 
 echo "🔍 Checking for leftover conflict markers / unmerged paths..."

package/src/scripts/pr_url_reminder_hook.ts

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+/**
+ * PostToolUse PR-URL reminder — reply-shape backstop for `direct-answers`.
+ *
+ * The `direct-answers` rule (reply-close) requires: a PR created THIS turn puts
+ * its raw URL as the **literal last line** of the reply. That is a behavioural
+ * rule with no deterministic backstop, so it can be silently missed — the URL
+ * ends up inline mid-reply instead of last. This hook fires right after a
+ * PR-creating tool call, extracts the created PR URL from the tool output, and
+ * WARNS in context (exit 2) so the reminder lands exactly when the PR is born,
+ * before the reply closes.
+ *
+ * Fires ONLY on an actual PR *create*:
+ *   - a shell command matching `gh pr create`, OR
+ *   - a GitHub tool whose name means "create a pull request"
+ *     (e.g. create_pull_request / createPullRequest / pulls.create),
+ * AND only when the tool output actually contains a `…/pull/<n>` URL — so a
+ * failed / dry-run create (no URL) does not nag, and `gh pr view/checks/list/
+ * comment` (which also print PR URLs) never fire it.
+ *
+ * Warn only — never blocks (fail_closed: false). Unconditional: it reinforces
+ * an always-on rule and only fires on the rare PR-create event, so it carries
+ * no settings gate (mirrors verify-before-complete / roadmap-progress).
+ *
+ * Exit codes (dispatcher contract): 0 allow · 2 warn (+ `{decision,reason}`
+ * JSON on stdout).
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const EXIT_ALLOW = 0;
+const EXIT_WARN = 2;
+
+type JsonValue = string | number | boolean | null | JsonValue[] | { [k: string]: JsonValue };
+type JsonObject = { [k: string]: JsonValue };
+
+// Tool names across platforms whose command field carries a shell command
+// (kept in lock-step with verify_before_complete_hook.COMMAND_TOOLS).
+const COMMAND_TOOLS: ReadonlySet<string> = new Set([
+  "launch-process",
+  "launch_process",
+  "Bash",
+  "BashTool",
+  "run-process",
+  "runProcess",
+  "shell",
+  "execute_shell",
+  "RunShellCommand",
+]);
+
+// A shell command that CREATES a pull request. Anchored on a shell separator so
+// it matches inside a chained command (`git push && gh pr create …`) but not a
+// substring of another word. `gh pr view/checks/list/comment` do not match.
+const _GH_PR_CREATE = /(?:^|[\s;&|`(])gh\s+pr\s+create\b/i;
+
+// A non-shell tool whose NAME means "create a pull request" (github-api / MCP).
+const _CREATE_PR_TOOL = /(?:create[_-]?pull_?request|createpullrequest|pulls[._-]create|create_pr\b)/i;
+
+// A GitHub pull-request URL as printed by `gh pr create` / returned as html_url.
+const _PR_URL = /https?:\/\/github\.com\/[^\s"'`<>]+\/pull\/\d+/i;
+
+function _isObject(v: unknown): v is JsonObject {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+/** Return [tool_name, command_text] from a tool-event payload. */
+function _extractCommand(payload: JsonObject): [string | null, string | null] {
+  const toolRaw = payload["tool_name"] ?? payload["toolName"] ?? payload["tool"];
+  const tool = typeof toolRaw === "string" ? toolRaw : null;
+  if (!(tool !== null && COMMAND_TOOLS.has(tool))) {
+    return [tool, null];
+  }
+  const ti = payload["tool_input"];
+  if (_isObject(ti)) {
+    for (const key of ["command", "cmd", "shell_command"]) {
+      const v = ti[key];
+      if (typeof v === "string" && v) {
+        return [tool, v];
+      }
+    }
+  }
+  for (const key of ["command", "cmd"]) {
+    const v = payload[key];
+    if (typeof v === "string" && v) {
+      return [tool, v];
+    }
+  }
+  return [tool, null];
+}
+
+/** Best-effort extraction of the tool-output text from the envelope. */
+function _toolOutput(envelope: JsonObject): string {
+  for (const key of ["tool_response", "tool_result", "toolResponse", "output", "result", "stdout"]) {
+    const v = envelope[key];
+    if (typeof v === "string") {
+      return v;
+    }
+    if (_isObject(v) || Array.isArray(v)) {
+      return JSON.stringify(v);
+    }
+  }
+  return JSON.stringify(envelope);
+}
+
+/** True when this tool event created a pull request. */
+function _isPrCreate(tool: string | null, command: string | null): boolean {
+  if (command !== null && _GH_PR_CREATE.test(command)) {
+    return true;
+  }
+  return tool !== null && _CREATE_PR_TOOL.test(tool);
+}
+
+export function main(): number {
+  let envelope: JsonValue;
+  try {
+    const raw = _readStdin();
+    envelope = raw.trim() ? (JSON.parse(raw) as JsonValue) : {};
+  } catch {
+    return EXIT_ALLOW; // never block on a malformed envelope
+  }
+  if (!_isObject(envelope)) {
+    return EXIT_ALLOW;
+  }
+
+  const [tool, command] = _extractCommand(envelope);
+  if (!_isPrCreate(tool, command)) {
+    return EXIT_ALLOW;
+  }
+
+  const match = _PR_URL.exec(_toolOutput(envelope));
+  if (match === null) {
+    return EXIT_ALLOW; // create attempted but no URL produced (failed / dry-run) — do not nag
+  }
+  const url = match[0];
+
+  // `reason` (≤ 200 chars) goes to stderr; `additional_context` is what
+  // surfaces back to the model on platforms that support it — so the
+  // actionable instruction lives there (a stderr-only reason would not
+  // change the reply that this hook exists to shape).
+  const reason = `PR created this turn (${url}) — end your reply with this raw URL as the literal last line (direct-answers/reply-close).`;
+  const additional_context =
+    `You created a pull request this turn: ${url}\n\n` +
+    `Per the direct-answers rule (reply-close): a PR created this turn must appear ` +
+    `as the raw URL on the LITERAL LAST LINE of your reply — not inline mid-message. ` +
+    `Before ending the turn, make your final line exactly:\n${url}\n` +
+    `If it already is, no action needed.`;
+  process.stdout.write(`${JSON.stringify({ decision: "warn", reason, additional_context })}\n`);
+  return EXIT_WARN;
+}
+
+function _readStdin(): string {
+  return fs.readFileSync(0, "utf-8");
+}
+
+function _isCliEntry(): boolean {
+  if (process.argv[1] === undefined) {
+    return false;
+  }
+  const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  // Symlinked invocation (installed projection, or macOS /var → /private/var
+  // temp dirs) makes the raw URLs differ; compare realpaths so the guard fires.
+  try {
+    const here = fs.realpathSync(fileURLToPath(import.meta.url));
+    const argv = fs.realpathSync(path.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+
+if (_isCliEntry()) {
+  process.exit(main());
+}

package/src/scripts/schemas/agent-settings.schema.json

@@ -84,6 +84,17 @@
         }
       }
     },
+    "consistency": {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "cross_source": {
+          "type": "string",
+          "enum": ["on", "auto", "off"],
+          "description": "Consumed by the cross-source-consistency rule. When the agent works from multiple sources (ticket text, an attached image/mockup, the spec, the codebase) it checks them against each other and asks before proceeding on a discrepancy. on (default) = surface every real cross-source contradiction / silent-scope-expansion as one question; auto = surface only high-confidence contradictions, state low-confidence as an assumption; off = no cross-source checking."
+        }
+      }
+    },
     "code_style": {
       "type": "object",
       "additionalProperties": true,

package/src/server/schemas/settings.ts

@@ -26,6 +26,7 @@ const qualityCadence = z.enum(['end_of_roadmap', 'per_phase', 'per_step']);
 const regenCadence = z.enum(['per_step', 'every_5_steps', 'phase_boundary']);
 const worktreeMode = z.enum(['off', 'on', 'ask']);
 const fidelityMode = z.enum(['strict', 'structural', 'hard-floor']);
+const crossSourceMode = z.enum(['on', 'auto', 'off']);
 const richSkillsMode = z.enum(['on', 'ask', 'off']);
 const replyMethod = z.enum(['replies_endpoint', 'create_review_comment', 'auto']);
 const confidenceBand = z.enum(['off', 'low', 'medium', 'high']);
@@ -203,6 +204,11 @@ export const settingsSchema = z.object({
             'How strictly the agent must follow a user-provided prototype / mockup / design system (consumed by the design-fidelity rule). strict = build 1:1, every visible deviation needs confirmation; structural = structure locked, silent gaps fillable with a stated assumption; hard-floor = any deviation is never autonomous.',
         ),
     }).default({ fidelity_mode: 'strict' }),
+    consistency: z.object({
+        cross_source: crossSourceMode.default('on').describe(
+            'Consumed by the cross-source-consistency rule. When the agent works from multiple sources (ticket text, an attached image/mockup, the spec, the codebase) it checks them against each other and asks before proceeding on a discrepancy — instead of silently guessing. on (default) = surface every real cross-source contradiction / silent-scope-expansion as one question; auto = surface only high-confidence contradictions, state low-confidence as an assumption; off = no cross-source checking.',
+        ),
+    }).default({ cross_source: 'on' }),
     tokens: z.object({
         rich_skills: richSkillsMode.default('on').describe(
             'Whether skills marked token_budget_class: rich may load in full (exempt from telegraph-speak + thin-projector trimming), consumed by the token-budget-discipline rule. on = allowed (default); off = fall back to standard condensed behavior; ask = surface an estimated token delta (tokens, not dollars) and ask once per session before loading.',
@@ -282,6 +288,9 @@ export const settingsSchema = z.object({
         max_parallel: z.number().int().min(1).default(3).describe(
             'Hard cap on subagents running in parallel during /do-in-parallel, /do-competitively, and /judge runs. Raise for faster fan-out, lower if you hit rate limits or want lower token spend.',
         ),
+        adversarial_council: z.enum(['off', 'ask', 'on']).default('off').describe(
+            'Opt-in adversarial-verification-council mode (subagent-orchestration Mode 9, ADR-122). off (default) = never runs; ask = offer it on an explicit high-risk change; on = auto-run on high-risk changes. Advisory only — a panel of distinct-model skeptics red-teams a real change for defect FINDING coverage and NEVER auto-gates it (Hard Floor). Stays default-off until the adversarial-council-finding-coverage claim is backed.',
+        ),
     }),
     worktrees: z.object({
         mode: worktreeMode.default('ask').describe(