coding-os 0.3.2__py3-none-any.whl

scheduled/responsive_extract.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+"""Responsive learn_extract trigger — fired by session-end.sh (Stop hook).
+
+When at least ``responsive_extract_threshold`` new task_outcomes have accrued
+since the last extract, mine patterns now instead of waiting for the nightly
+daemon — so same-day outcomes feed ``cos_learn_suggest`` in the next session.
+Bounded, fire-and-forget; shares the ``.last-extract`` marker with nightly so
+the two paths stay idempotent. No-op when scheduled config has enabled=false.
+
+argv: <session_id> <active_task> <db_path>  (passed by session-end run_bounded_python)
+Contract: docs/engineering/scheduled-jobs.md § Configurable cadence + responsive extraction.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+import sys
+from pathlib import Path
+
+_HERE = Path(__file__).resolve().parent
+_CORE = _HERE.parent
+_SRC = _CORE.parent
+_THINKING_OS = _CORE / "thinking_os"
+# src/ FIRST so `from core.<pkg>` resolves — a hook-invoked as-file script has no
+# editable install to lean on. Then core/ + thinking_os/ for flat sibling imports.
+for _p in (str(_SRC), str(_CORE), str(_THINKING_OS)):
+    if _p not in sys.path:
+        sys.path.insert(0, _p)
+
+from scheduled._activity import outcomes_since_marker  # noqa: E402
+from scheduled._state import state_dir, touch_marker  # noqa: E402
+from scheduled.config import load_config  # noqa: E402
+
+
+def main() -> int:
+    if len(sys.argv) < 4:
+        return 0
+    db_path = Path(sys.argv[3])
+    if not db_path.exists():
+        return 0
+    # db lives at <root>/.coding-os/coding-os.db → project_root is two up.
+    project_root = db_path.parent.parent
+    try:
+        cfg = load_config(project_root)
+        if not cfg["enabled"]:
+            return 0
+        marker = state_dir(project_root) / ".last-extract"
+        if outcomes_since_marker(db_path, marker) < int(cfg["responsive_extract_threshold"]):
+            return 0
+        with sqlite3.connect(str(db_path), timeout=5) as conn:
+            conn.row_factory = sqlite3.Row
+            total = conn.execute("SELECT COUNT(*) FROM task_outcomes").fetchone()[0]
+            if total < int(cfg["learn_extract_min_outcomes"]):
+                return 0
+            from tools.learning import learn_extract
+
+            learn_extract(conn)
+        touch_marker(marker)
+    except Exception:
+        return 0
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/__init__.py

@@ -0,0 +1,4 @@
+"""Marker so the bundled shell scripts (git-hook bodies, installers) ship as
+wheel package-data. The .sh files ride along via package-data so an installed
+`cos init` can install consumer git hooks. TASK-219.
+"""

scripts/_commit_msg_body.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+# cos commit-msg — enforce commit message contract for human/agent direct commits.
+# Installed by: bash src/scripts/install-git-hooks.sh
+# Defense-in-depth alongside PreToolUse Bash hook enforce-commit-message.sh —
+# this layer fires for runtimes that don't honor PreToolUse hooks (Codex GUI, raw human).
+set -euo pipefail
+
+REPO_ROOT="$(git rev-parse --show-toplevel)"
+# Meta-repo path first; fall back to a consumer's symlinked adapter hooks dir
+# (.claude/.codex) so the commit-message contract still fires in a
+# `cos init` project, which has no src/core/ of its own. Mirrors
+# the HOOKS_DIR resolution already in _pre_commit_body.sh.
+HELPER="${REPO_ROOT}/src/core/hooks/_helpers/check_commit_message.py"
+if [[ ! -f "$HELPER" ]]; then
+  for _ad in .claude .codex; do
+    _cand="${REPO_ROOT}/${_ad}/hooks/_helpers/check_commit_message.py"
+    if [[ -f "$_cand" ]]; then HELPER="$_cand"; break; fi
+  done
+fi
+
+if [[ ! -f "$HELPER" ]]; then
+  exit 0
+fi
+
+if ! python3 "$HELPER" "$1" ; then
+  echo "" >&2
+  echo "Spec: src/core/rules/git-workflow.md § Commit Message Contract" >&2
+  echo "Override (NOT recommended): git commit --no-verify ..." >&2
+  exit 1
+fi
+exit 0

scripts/_post_commit_body.sh

@@ -0,0 +1,49 @@
+#!/usr/bin/env bash
+# cos post-commit — append a Work Log line to the task shipped in this commit.
+# Installed by: bash src/scripts/install-git-hooks.sh
+#
+# The task is detected from the committed docs/tasks/TASK-NNN-*.md file — robust,
+# no panel/session resolution needed. Logs the committed CODE files + short sha.
+# Idempotent per sha; fail-OPEN (the commit already landed — never error out).
+set -eu
+
+REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || true)"
+[ -n "$REPO_ROOT" ] || exit 0
+
+SHA="$(git rev-parse --short HEAD 2>/dev/null || true)"
+[ -n "$SHA" ] || exit 0
+
+FILES="$(git show --name-only --format= HEAD 2>/dev/null || true)"
+[ -n "$FILES" ] || exit 0
+
+# The task this commit belongs to = the committed task file (first one wins).
+TASK_FILE="$(printf '%s\n' "$FILES" | grep -oE 'docs/tasks/TASK-([A-Z][A-Z0-9]*-)?[0-9]+-[^/]*\.md' | head -1 || true)"
+[ -n "$TASK_FILE" ] || exit 0
+TASK_ID="$(printf '%s' "$TASK_FILE" | grep -oE 'TASK-([A-Z][A-Z0-9]*-)?[0-9]+' | head -1 || true)"
+[ -n "$TASK_ID" ] || exit 0
+
+# Code files = committed files that are NOT task markdown. No code → nothing to
+# log (also breaks the self-referential loop when only the work-log line lands).
+CODE_FILES="$(printf '%s\n' "$FILES" | sed '/^$/d' | grep -vE 'docs/tasks/TASK-([A-Z][A-Z0-9]*-)?[0-9]+-[^/]*\.md' || true)"
+[ -n "$CODE_FILES" ] || exit 0
+
+# Idempotent: skip if this sha is already recorded in the task body.
+if grep -q "committed ${SHA}" "${REPO_ROOT}/${TASK_FILE}" 2>/dev/null; then
+  exit 0
+fi
+
+# Log the sha + file COUNT, not the file list: the list is fully recoverable
+# via `git show --name-only <sha>`, so enumerating it only produced a long,
+# git-redundant string that the 120-char Work Log cap then truncated mid-path.
+COUNT="$(printf '%s\n' "$CODE_FILES" | wc -l | tr -d ' ')"
+if [ "$COUNT" -eq 1 ]; then
+  SUMMARY="committed ${SHA} · ${COUNT} file"
+else
+  SUMMARY="committed ${SHA} · ${COUNT} files"
+fi
+
+HELPER="${COS_WORKLOG_HELPER:-${REPO_ROOT}/src/core/hooks/_helpers/work_log_append.py}"
+[ -f "$HELPER" ] || exit 0
+COS_PROJECT_ROOT="$REPO_ROOT" python3 "$HELPER" "$TASK_ID" "$SUMMARY" >/dev/null 2>&1 || true
+
+exit 0

scripts/_pre_commit_body.sh

@@ -0,0 +1,121 @@
+#!/usr/bin/env bash
+# cos pre-commit — critical validation for human direct edits.
+# Installed by: bash scripts/install-git-hooks.sh
+# Covers the enforcement gap where a human editing files directly bypasses
+# ALL PreToolUse:Write|Edit hooks.
+set -euo pipefail
+
+REPO_ROOT="$(git rev-parse --show-toplevel)"
+HOOKS_DIR="${REPO_ROOT}/src/core/hooks"
+
+if [[ ! -d "$HOOKS_DIR" && -d "${REPO_ROOT}/core/hooks" ]]; then
+  HOOKS_DIR="${REPO_ROOT}/core/hooks"
+fi
+if [[ -d "${REPO_ROOT}/.claude/hooks" ]]; then
+  HOOKS_DIR="${REPO_ROOT}/.claude/hooks"
+fi
+
+source "${HOOKS_DIR}/cos-env.sh" 2>/dev/null || true
+
+# _helpers/ is NOT symlinked into a consumer's .claude/hooks/, so resolve it
+# through cos-env.sh's own symlink chain (then fall back to the meta tree).
+HELPERS_DIR="${HOOKS_DIR}/_helpers"
+if command -v _cos_helpers_dir >/dev/null 2>&1; then
+  HELPERS_DIR="$(_cos_helpers_dir)"
+fi
+[[ -d "$HELPERS_DIR" ]] || HELPERS_DIR="${REPO_ROOT}/src/core/hooks/_helpers"
+
+STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM 2>/dev/null || true)
+
+if [[ -z "$STAGED_FILES" ]]; then
+  exit 0
+fi
+
+FILE_COUNT=$(echo "$STAGED_FILES" | wc -l | tr -d ' ')
+echo "cos pre-commit: checking ${FILE_COUNT} staged file(s)..."
+
+# Committed agent memory (.agents/memory/**) travels to the remote — a leaked
+# credential there is public. Scan staged memory files for classic secret
+# shapes and BLOCK on any hit (fail-closed for this narrow, high-risk path).
+MEMORY_STAGED=$(echo "$STAGED_FILES" | grep -E '^\.agents/memory/' || true)
+if [[ -n "$MEMORY_STAGED" ]]; then
+  SECRET_RE='-----BEGIN [A-Z ]*PRIVATE KEY|AKIA[0-9A-Z]{16}|ghp_[A-Za-z0-9]{36}|github_pat_[A-Za-z0-9_]{22,}|xox[baprs]-[A-Za-z0-9-]{10,}|sk-[A-Za-z0-9]{20,}|AIza[0-9A-Za-z_-]{35}'
+  # Process substitution, never a herestring read-loop: the herestring's
+  # tmp-file path deadlocks under bash 5.3.9 in git's hook environment
+  # (repo-wide ban, enforced by test_pre_commit_no_deadlock).
+  while IFS= read -r mem_file; do
+    [[ -f "$mem_file" ]] || continue
+    if git show ":$mem_file" 2>/dev/null | grep -qE "$SECRET_RE"; then
+      echo "cos pre-commit: BLOCKED — credential-shaped content in $mem_file" >&2
+      echo "  .agents/memory is committed and shared; remove the secret before committing." >&2
+      exit 1
+    fi
+  done < <(printf '%s\n' "$MEMORY_STAGED")
+fi
+
+# Delegate the per-file iteration to a single Python helper. The previous
+# bash-loop implementation (even with mktemp IPC) deadlocks git-commit's
+# hook environment beyond ~15 staged files — bash 5.x fork-bombs and
+# loses pipe synchronization. The Python helper does the same work in
+# one process: no nested subshells, no per-file fork-bomb.
+BATCH_HELPER="${HELPERS_DIR}/pre_commit_batch.py"
+
+if [[ ! -f "$BATCH_HELPER" ]]; then
+  echo "cos pre-commit: WARNING — batch helper missing; skipping hook scan." >&2
+  echo "  expected at: $BATCH_HELPER" >&2
+  exit 0
+fi
+
+# Pass file list as positional args (one per arg, no shell-word splits).
+# Feed the loop via process substitution, NOT a `<<<` here-string: `<<<`
+# writes the whole list to a self-pipe before the reader drains it, which
+# deadlocks once the (shared-index) staged set exceeds the pipe buffer — the
+# bash 5.x heredoc deadlock this file's own header warns about (Rule 8). The
+# `< <(printf …)` form is drained line-by-line by read, so it never buffers
+# the whole list and cannot deadlock regardless of staged-set size.
+FILE_ARGS=()
+while IFS= read -r FILE; do
+  [[ -z "$FILE" ]] && continue
+  FILE_ARGS+=("$FILE")
+done < <(printf '%s\n' "$STAGED_FILES")
+
+# Run the batch under a hard wall-clock ceiling so a stuck hook child can
+# never hang this commit (or orphan into the next one). pre_commit_batch.py
+# already kills each hook at 15s; this is the cumulative/python-level backstop.
+COS_PRECOMMIT_TIMEOUT="${COS_PRECOMMIT_TIMEOUT:-180}"
+source "${HELPERS_DIR}/run_with_reap_timeout.sh" 2>/dev/null || true
+
+set +e
+if command -v cos_run_with_reap_timeout >/dev/null 2>&1; then
+  cos_run_with_reap_timeout "$COS_PRECOMMIT_TIMEOUT" \
+    python3 "$BATCH_HELPER" "$HOOKS_DIR" "$REPO_ROOT" "${FILE_ARGS[@]}"
+else
+  python3 "$BATCH_HELPER" "$HOOKS_DIR" "$REPO_ROOT" "${FILE_ARGS[@]}"
+fi
+BATCH_RC=$?
+set -e
+
+if [[ "$BATCH_RC" -eq 0 ]]; then
+  echo "cos pre-commit: OK"
+  exit 0
+elif [[ "$BATCH_RC" -eq 1 ]]; then
+  echo "" >&2
+  echo "cos pre-commit: commit blocked. Fix the issues above and re-stage." >&2
+  echo "To skip (NOT recommended): git commit --no-verify" >&2
+  exit 1
+else
+  # Non-0/1: the watchdog reaped a hang (SIGKILL 137 / SIGTERM 143 / timeout
+  # 124) OR the batch helper itself crashed. Fail OPEN either way — a permanent
+  # block would brick commits (the agent path cannot use --no-verify) and
+  # PreToolUse hooks already validated agent edits — but distinguish the two so
+  # a real crash is not misreported as a benign timeout.
+  echo "" >&2
+  case "$BATCH_RC" in
+    124|137|143)
+      echo "cos pre-commit: WARNING — scan exceeded ${COS_PRECOMMIT_TIMEOUT}s and was reaped (orphans killed; rc=${BATCH_RC})." >&2 ;;
+    *)
+      echo "cos pre-commit: WARNING — scan helper crashed (rc=${BATCH_RC}); commit allowed but hooks did NOT fully run." >&2 ;;
+  esac
+  echo "  Commit allowed; re-run for a full scan if needed." >&2
+  exit 0
+fi

scripts/_prepare_commit_msg_body.sh

@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+# cos prepare-commit-msg — stamp the active task id into the commit subject so
+# cos_task_history (`git log --all --grep TASK-NNN`) links the commit to its
+# task regardless of WHO commits (terminal agent, human, Hub). Fires on every
+# commit; fail-OPEN — never blocks a commit, only enriches the message.
+#
+# Installed by: bash src/scripts/install-git-hooks.sh
+set -eu
+
+MSG_FILE="${1:-}"
+SRC="${2:-}"
+[ -n "$MSG_FILE" ] || exit 0
+[ -f "$MSG_FILE" ] || exit 0
+# Only ordinary commits — never touch merge/squash templates.
+case "$SRC" in
+  merge | squash) exit 0 ;;
+esac
+
+git rev-parse --show-toplevel >/dev/null 2>&1 || exit 0
+
+# Already names a task? leave the author's message untouched.
+if grep -qE 'TASK-([A-Z][A-Z0-9]*-)?[0-9]+' "$MSG_FILE" 2>/dev/null; then
+  exit 0
+fi
+
+_read_marker() {
+  [ -f "$1" ] || return 0
+  grep -oE 'TASK-([A-Z][A-Z0-9]*-)?[0-9]+' "$1" 2>/dev/null | head -1 || true
+}
+
+# Resolve the active task: an explicit env var wins (a task-scoped caller such
+# as the Hub can set it), else this panel's marker, else the agent-level marker.
+TASK_ID="$(printf '%s' "${COS_ACTIVE_TASK:-}" | grep -oE 'TASK-([A-Z][A-Z0-9]*-)?[0-9]+' | head -1 || true)"
+[ -n "$TASK_ID" ] || TASK_ID="$(_read_marker "${COS_PANEL_DIR:-}/.task-current")"
+[ -n "$TASK_ID" ] || TASK_ID="$(_read_marker "${COS_AGENT_DIR:-}/.task-current")"
+[ -n "$TASK_ID" ] || exit 0
+
+# Append " (TASK-NNN)" to the subject (first non-comment, non-empty line) — but
+# only when it keeps the title within the 100-char commit-msg contract, so this
+# can never make a later commit-msg-hook rejection. No room → leave it.
+awk -v tid="$TASK_ID" '
+  BEGIN { done = 0 }
+  /^#/ { print; next }
+  (!done && NF > 0) {
+    suffix = " (" tid ")"
+    if (index($0, tid) == 0 && length($0) + length(suffix) <= 100) $0 = $0 suffix
+    done = 1
+    print; next
+  }
+  { print }
+' "$MSG_FILE" > "${MSG_FILE}.cos" 2>/dev/null && mv "${MSG_FILE}.cos" "$MSG_FILE" || rm -f "${MSG_FILE}.cos"
+
+exit 0