@ccoalm/ccl-skills 0.15.0 → 0.15.1

package/dist/assets/marketplace/plugins/ccl-skills/skills/skill-extraction-workflow/scripts/impact-chain-gate.rb

@@ -5,7 +5,7 @@
 # upstream-owner skill must declare a behavioral-evidence status and an
 # observed-failure state, and (for non-wording changes) name an owner-scoped
 # FIRING PATH that resolves to this diff — an anchor on a changed normative
-# rule line, or a changed owner executable. The statuses are required author
+# rule or table data line, or a changed owner executable. The statuses are required author
 # declarations; the firing path and the wording-only classification are the
 # machine-verified core. Extracted from the former inline `ruby -e` block in
 # check-ccl-skills.sh so the program gets normal Ruby tooling and no
@@ -1141,9 +1141,80 @@ if upstream.any? || routing_entrypoint_changed || changed_paths.include?(LEDGER_
         blob[:content].scan(Regexp.new(Regexp.escape(anchor))).length == 1
     end
   end
+  # Definition/decision tables are firing surfaces too. Recognize explicit
+  # Markdown tables with a header and delimiter; comments and code examples do
+  # not count. This proves location/shape, not the truth of the definition.
+  table_data_anchor_valid = lambda do |scope, parts|
+    prior = blob_at.call(scope.base, parts[:path])
+    next false if prior && prior[:content].include?(parts[:anchor])
+    previous_cells = nil
+    columns = nil
+    fence = nil
+    comment = false
+    raw_html = nil
+    html_block = false
+    head_blob.call(scope, parts[:path])[:content].each_line do |raw_line|
+      line = raw_line.chomp
+      if fence
+        fence = nil if line.match?(/\A {0,3}#{Regexp.escape(fence[0])}{#{fence.length},}\s*\z/)
+        next
+      end
+      if raw_html
+        raw_html = nil if line.match?(raw_html)
+        next
+      end
+      if html_block
+        html_block = false if line.strip.empty?
+        next
+      end
+      hidden = comment || line.include?("<!--") || line.include?("-->")
+      line.scan(/<!--|-->/).each { |marker| comment = marker == "<!--" }
+      if hidden
+        previous_cells = columns = nil
+        next
+      end
+      if (opening = line.match(/\A {0,3}(`{3,}|~{3,})/))
+        fence = opening[1]
+        previous_cells = columns = nil
+        next
+      end
+      terminator = case line
+                   when /\A {0,3}<\?/ then /\?>/
+                   when /\A {0,3}<!\[CDATA\[/ then /\]\]>/
+                   when /\A {0,3}<![A-Z]/ then />/
+                   end
+      if terminator
+        raw_html = terminator unless line.match?(terminator)
+        previous_cells = columns = nil
+        next
+      end
+      if line.match?(%r{\A {0,3}</?[A-Za-z][\w-]*(?:\s|>|/|\z)})
+        tag = line[/\A {0,3}<(script|pre|style|textarea)(?:\s|>|\z)/i, 1]
+        raw_html = %r{</#{tag}\s*>}i if tag && !line.match?(%r{</#{tag}\s*>}i)
+        html_block = !tag
+        previous_cells = columns = nil
+        next
+      end
+      unless line.match?(/\A {0,3}\|.*\|\s*\z/)
+        previous_cells = columns = nil
+        next
+      end
+      cells = line.strip[1...-1].split(/(?<!\\)\|/, -1).map(&:strip)
+      delimiter = cells.length >= 2 && cells.all? { |cell| cell.match?(/\A:?-{3,}:?\z/) }
+      if delimiter
+        columns = previous_cells && previous_cells.length == cells.length ? cells.length : nil
+      elsif columns && columns == cells.length
+        break true if cells.any? { |cell| cell.include?(parts[:anchor]) }
+      else
+        columns = nil
+      end
+      previous_cells = cells
+    end == true
+  end
   enforcing_file_locator_valid = lambda do |scope, parts|
     next false unless parts && parts[:kind] == "file"
     next false unless parts[:path].end_with?(".md")
+    next false if parts[:path] == LEDGER_PATH # Evidence cannot certify itself.
     next false unless locator_valid.call(scope, "file:#{parts[:path]}##{parts[:anchor]}")
     line = added_lines_for.call(scope, parts[:path]).find { |added| added.include?(parts[:anchor]) }
     next false unless line
@@ -1161,7 +1232,7 @@ if upstream.any? || routing_entrypoint_changed || changed_paths.include?(LEDGER_
     # "the adapter does not support"), and single characters with broad
     # compounds (应/只/别 — 应用/只是/区别).
     normative = line.match?(/(?:\b(?:must|shall|never|do\s+not|don'?t|required?|requires?|block(?:s|ed)?|reject(?:s|ed)?|deny|denied|invalidates?|forbid(?:s|den)?|cannot|enforcement)\b|必须|不得|禁止|拒绝|作废|仅限|只能|应当|应该|务必|不能|不允许|不可)/i)
-    list_rule && normative
+    (list_rule && normative) || table_data_anchor_valid.call(scope, parts)
   end
   # A routing-surface-only owner has no changed rule line to anchor on: its whole
   # change is one YAML scalar. The answer is NOT to exempt it — a description edit
@@ -1360,7 +1431,7 @@ if upstream.any? || routing_entrypoint_changed || changed_paths.include?(LEDGER_
       firing_parts = locator_parts.call(firing_path)
       firing_path_valid = firing_locator_valid.call(row_scope, firing_parts, owner)
       # The machine-checked core is the FIRING PATH (an owner-scoped anchor on a
-      # changed normative rule, or a changed owner executable) plus the
+      # changed normative rule/table data, or a changed owner executable) plus the
       # deterministic wording-only classification. The behavioral-evidence
       # status and observed-failure fields are required author declarations —
       # honest labels, not digest-verified artifacts: a digest-bound evidence

package/dist/assets/marketplace/plugins/ccl-skills/skills/skill-extraction-workflow/scripts/skill-behavior-eval.py

@@ -52,7 +52,7 @@ Usage:
 Run in a SCRATCH checkout: the current arm executes the installed hooks/plugins (not just the
 read-only model tools), so treat it as potentially side-effecting, not inert.
 """
-import argparse, hashlib, json, os, re, subprocess, sys, threading, time
+import argparse, hashlib, json, os, re, signal, subprocess, sys, time
 
 HERE = os.path.dirname(os.path.abspath(__file__))
 DEFAULT_FIXTURES = os.path.normpath(os.path.join(HERE, "..", "..", "..", "eval", "behavior-fixtures.jsonl"))
@@ -100,23 +100,62 @@ def _headless_claude(cmd, prompt, timeout_s):
         # stderr → DEVNULL: we never read it, and a full stderr pipe would deadlock the child
         # on a verbose run and time out an otherwise-valid answer.
         p = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
-                             stderr=subprocess.DEVNULL, text=True)
+                             stderr=subprocess.DEVNULL, text=True,
+                             start_new_session=(os.name == "posix"))
     except FileNotFoundError:
         return None, "claude_not_found", None, []
-    out = {"s": ""}
-    t = threading.Thread(target=lambda: out.__setitem__("s", p.stdout.read()))
-    t.start()
     try:
-        p.stdin.write(prompt); p.stdin.close()
-    except (BrokenPipeError, OSError):
-        pass
-    t.join(timeout_s)
-    if t.is_alive():
-        p.kill(); t.join(2)
-        return None, f"timeout_{timeout_s}s", None, []
-    rc = p.wait()
+        # One deadline covers stdin backpressure, stdout collection and process
+        # completion. A reader-only timer leaves writes and p.wait() unbounded.
+        out, _ = p.communicate(input=prompt, timeout=timeout_s)
+    except BaseException as stopped:
+        # The group can outlive its leader while a descendant holds stdout open.
+        # Kill the recorded group even when the direct child has already exited.
+        cleanup_errors = []
+        try:
+            if os.name == "posix":
+                os.killpg(p.pid, signal.SIGKILL)
+            else:
+                cleanup_errors.append("descendant_cleanup_unsupported")
+                p.kill()
+        except ProcessLookupError:
+            pass
+        except PermissionError:
+            target = "group" if os.name == "posix" else "process"
+            cleanup_errors.append(f"{target}_kill_permission_denied")
+        try:
+            p.communicate(timeout=1)
+        except (subprocess.TimeoutExpired, OSError) as cleanup_error:
+            # An escaped descendant may still own a pipe; do not wait for EOF.
+            cleanup_errors.append("stdio_timeout" if isinstance(cleanup_error, subprocess.TimeoutExpired) else "stdio_error")
+            try:
+                p.kill()
+            except ProcessLookupError:
+                pass
+            except PermissionError:
+                cleanup_errors.append("process_kill_permission_denied")
+            try:
+                p.wait(timeout=1)
+            except (subprocess.TimeoutExpired, OSError) as cleanup_error:
+                cleanup_errors.append("wait_timeout" if isinstance(cleanup_error, subprocess.TimeoutExpired) else "wait_error")
+        # A denied kill or incomplete drain/reap is not evidence of cleanup.
+        # Return it so callers can save partial results and stop new processes.
+        interrupted = not isinstance(stopped, subprocess.TimeoutExpired)
+        error = "interrupted" if interrupted else f"timeout_{timeout_s}s"
+        if cleanup_errors:
+            error += ";cleanup_unconfirmed:" + ",".join(cleanup_errors)
+        if interrupted:
+            if cleanup_errors:
+                print(f"{error}; confirm process termination before resuming", file=sys.stderr)
+            raise
+        return None, error, None, []
+    finally:
+        p.stdin.close()
+        p.stdout.close()
+    rc = p.returncode
     parts, result_text, result_subtype, util, invoked = [], None, None, None, []
-    for ln in out["s"].splitlines():
+    terminal_results = []
+    for ln in out.splitlines():
         # The stream is external/untrusted: a line may be invalid JSON, deeply nested (RecursionError),
         # or a shape-drifted value. Wrap the WHOLE per-line parse+extract so any bad line skips itself
         # and never crashes the eval run (fail-closed-skip). We read only known fields of known event
@@ -127,6 +166,7 @@ def _headless_claude(cmd, prompt, timeout_s):
             if not isinstance(ev, dict):
                 continue
             if ev.get("type") == "result":
+                terminal_results.append(ev)
                 result_subtype = ev.get("subtype")
                 if result_subtype == "success":
                     result_text = ev.get("result")
@@ -159,8 +199,19 @@ def _headless_claude(cmd, prompt, timeout_s):
     # teardown failure — the answer is complete, accept. Without that event we do NOT bank the
     # text, even if some assistant chunks streamed and rc==0: a truncation or format drift before
     # the terminal event would otherwise be recorded as a valid sample.
-    if result_subtype == "success":
-        return ("\n\n".join(parts) if parts else result_text), None, util, invoked
+    if len(terminal_results) > 1:
+        return None, "invalid_terminal_result", util, invoked
+    if result_subtype == "success" and terminal_results:
+        terminal = terminal_results[0]
+        if (terminal.get("is_error") not in (None, False)
+                or terminal.get("permission_denials")
+                or terminal.get("api_error_status") not in (None, 0, "0")
+                or terminal.get("terminal_reason") not in (None, "completed")):
+            return None, "invalid_terminal_result", util, invoked
+        text = "\n\n".join(parts) if parts else result_text
+        if not isinstance(text, str) or not text.strip():
+            return None, "invalid_terminal_result", util, invoked
+        return text, None, util, invoked
     if rc != 0:
         return None, f"claude_exit_{rc}", util, invoked
     if result_subtype:
@@ -312,8 +363,12 @@ def build_report(rows, out_dir, do_judge, timeout_s, last_util, stop_util,
     in the summary (never silently dropped, or the report reads clean when it isn't). Raw responses
     stay on disk for audit; judgment-ASSIST, never a score. do_judge=False → fill-in scaffold."""
     verdicts = []
+    cleanup_error = None
     for fx in rows:
         base = {"id": fx["id"], "axis": fx.get("axis", "")}
+        if cleanup_error:
+            verdicts.append({**base, "status": "judge-skipped", "note": cleanup_error})
+            continue
         cur = read_saved_response(os.path.join(out_dir, f"{fx['id']}.current.s1.txt"))
         cand = read_saved_response(os.path.join(out_dir, f"{fx['id']}.candidate.s1.txt"))
         if not cur or not cand:
@@ -342,6 +397,8 @@ def build_report(rows, out_dir, do_judge, timeout_s, last_util, stop_util,
             last_util = util
         if err:
             verdicts.append({**base, "status": f"judge-error:{err}"})
+            if ";cleanup_unconfirmed:" in err:
+                cleanup_error = err
             continue
         v.update(base); v["status"] = "judged"
         if fixture_needs_human(fx):
@@ -467,8 +524,10 @@ def main():
         if not a.no_judge:
             print(f"--report-only will make up to {len(rows)} LLM-judge claude call(s) "
                   f"(one per fixture with both arms saved). Use --no-judge for a fill-in scaffold.")
-        build_report(rows, a.out, not a.no_judge, a.timeout, None, a.stop_util, ctext, a.current_tag)
+        verdicts = build_report(rows, a.out, not a.no_judge, a.timeout, None, a.stop_util, ctext, a.current_tag)
         print(f"\nReport: {os.path.join(a.out, 'capability-delta-report.md')}")
+        if any(";cleanup_unconfirmed:" in v["status"] for v in verdicts):
+            sys.exit(1)
         return
     # Fail fast: don't burn every current-arm run and only then discover the candidate
     # arm has no contract to inject.
@@ -501,6 +560,12 @@ def main():
                           f"{a.stop_util:.0%} — stopping before [{fx['id']}/{arm}/s{s}]. "
                           f"Partial results in {a.out}; rerun to continue, then --report-only.")
                     logf.close(); return
+                # A failed replacement must not leave its old response usable.
+                # Invalidate only after quota allows this sample to start.
+                try:
+                    os.unlink(rpath)
+                except FileNotFoundError:
+                    pass
                 t0 = time.time()
                 text, err, util, invoked = run_agent(fx["prompt"], a.timeout, arm, a.contract)
                 dt = time.time() - t0
@@ -509,7 +574,13 @@ def main():
                 if err:
                     print(f"[{fx['id']}/{arm}/s{s}] ERROR {err} ({dt:.0f}s)")
                     logf.write(json.dumps({"id": fx["id"], "arm": arm, "sample": s, "error": err}) + "\n")
-                    logf.flush(); continue
+                    logf.flush()
+                    if ";cleanup_unconfirmed:" in err:
+                        print(f"*** ABORT: process cleanup is unconfirmed; no further samples or judges started. "
+                              f"Partial results in {a.out}. Confirm process termination before resuming.")
+                        logf.close()
+                        sys.exit(1)
+                    continue
                 with open(rpath, "w", encoding="utf-8") as rf:
                     rf.write(f"# sig: {sig}\n")
                     rf.write(f"# {fx['id']} / arm={arm} / sample={s} / {dt:.0f}s / util={last_util}\n")
@@ -528,13 +599,24 @@ def main():
     if "current" in arms and "candidate" in arms:
         print("Building capability-delta report (candidate vs current)"
               + ("" if a.no_judge else " via LLM-judge — this makes more claude calls") + " ...")
-        build_report(rows, a.out, not a.no_judge, a.timeout, last_util, a.stop_util,
-                     contract_text, a.current_tag)
+        verdicts = build_report(rows, a.out, not a.no_judge, a.timeout, last_util, a.stop_util,
+                                contract_text, a.current_tag)
         print(f"Report: {os.path.join(a.out, 'capability-delta-report.md')} "
               f"(confirm every 🔴 HUMAN row by eye; it is judgment-assist, not a score).")
+        if any(";cleanup_unconfirmed:" in v["status"] for v in verdicts):
+            sys.exit(1)
     else:
         print("Single arm — no delta to report. Run --both-arms for the capability-delta report.")
 
 
 if __name__ == "__main__":
-    main()
+    previous_sigterm = signal.getsignal(signal.SIGTERM)
+    if previous_sigterm == signal.SIG_DFL:
+        def terminate(signum, _frame):
+            raise SystemExit(128 + signum)
+        signal.signal(signal.SIGTERM, terminate)
+    try:
+        main()
+    finally:
+        if previous_sigterm == signal.SIG_DFL:
+            signal.signal(signal.SIGTERM, previous_sigterm)

package/dist/assets/marketplace/plugins/ccl-skills/skills/skill-extraction-workflow/scripts/test_check_ccl_impact_chain_refscripts.sh

@@ -48,6 +48,10 @@ printf '# fixture slug-named reference\n\nNeutral placeholder for the inner-rena
 # and isolate the prose-only guard from the reproduction check.
 printf '# fixture slug mention: platform-observability\n' >> "$REPO/skills/product-rd-workflow/scripts/check-agent-contract-coverage.sh"
 printf '\nFixture eligible sibling mention: platform-observability.\n' >> "$REPO/skills/product-rd-workflow/references/adr-convention.md"
+# A real table baseline distinguishes a changed definition from an old anchor
+# surviving an unrelated source-link edit on the same line.
+TABLE_REL="skills/product-rd-workflow/references/zz-fixture-definition.md"
+printf '# Definitions\n\n| Metric | Definition | Source |\n| --- | --- | --- |\n| Incident deployment ratio | Deployments needing later work | old-source |\n' > "$REPO/$TABLE_REL"
 git -C "$REPO" add -A
 git -C "$REPO" commit -qm "seed throwaway upstream reference"
 git -C "$REPO" branch fixture-base HEAD
@@ -154,6 +158,75 @@ run_gate
 assert_not_contains "impact_chain_firing_path_missing" "$out" "a never-phrased normative rule should satisfy the firing-path gate"
 assert_rc "$rc" 0 "a never-phrased normative list rule must be accepted"
 
+# Definitions are executable guidance even when their Markdown surface is a
+# table instead of a normative list. Negative controls keep anchors bound to
+# new, rendered data cells in the correct owner and round.
+definition_table_case() {
+  local label="$1" expected="$2" anchor='Unplanned deployments caused by production incidents'
+  local firing_path="$TABLE_REL"
+  new_case "case-ref-definition-table-$label"
+  case "$label" in
+    surviving-anchor)
+      anchor='Deployments needing later work'
+      perl -pi -e 's/old-source/new-source/' "$REPO/$TABLE_REL" ;;
+    unchanged-table)
+      anchor='Deployments needing later work'
+      printf '\nChanged neighboring prose.\n' >> "$REPO/$TABLE_REL" ;;
+    *)
+      perl -pi -e 's/Deployments needing later work/Unplanned deployments caused by production incidents/' "$REPO/$TABLE_REL" ;;
+  esac
+  case "$label" in
+    foreign-owner)
+      firing_path='skills/terminal-cli-dev/references/zz-fixture-definition.md'
+      cp "$REPO/$TABLE_REL" "$REPO/$firing_path" ;;
+    duplicate) printf '\n%s\n' "$anchor" >> "$REPO/$TABLE_REL" ;;
+    inline-comment) perl -pi -e 's/Unplanned deployments caused by production incidents/<!-- Unplanned deployments caused by production incidents -->/' "$REPO/$TABLE_REL" ;;
+    multiline-comment) perl -0777 -pi -e 's/\n\| Metric/\n<!--\n| Metric/; $_ .= "-->\n"' "$REPO/$TABLE_REL" ;;
+    backtick-fence) perl -0777 -pi -e 's/\n\| Metric/\n```markdown\n| Metric/; $_ .= "```\n"' "$REPO/$TABLE_REL" ;;
+    tilde-fence) perl -0777 -pi -e 's/\n\| Metric/\n~~~markdown\n| Metric/; $_ .= "~~~\n"' "$REPO/$TABLE_REL" ;;
+    raw-html) perl -0777 -pi -e 's/\n\| Metric/\n<script>\n\n| Metric/; $_ .= "<\/script>\n"' "$REPO/$TABLE_REL" ;;
+    raw-html-open-line) perl -0777 -pi -e 's/\n\| Metric/\n<script\n| Metric/; $_ .= "<\/script>\n"' "$REPO/$TABLE_REL" ;;
+    processing-instruction) perl -0777 -pi -e 's/\n\| Metric/\n<?xml\n| Metric/; $_ .= "?>\n"' "$REPO/$TABLE_REL" ;;
+    cdata) perl -0777 -pi -e 's/\n\| Metric/\n<![CDATA[\n| Metric/; $_ .= "]]>\n"' "$REPO/$TABLE_REL" ;;
+    declaration) perl -0777 -pi -e 's/\n\| Metric/\n<!DOCTYPE\n| Metric/; $_ .= ">\n"' "$REPO/$TABLE_REL" ;;
+    closed-cdata) perl -0777 -pi -e 's/\n\| Metric/\n<![CDATA[\nclosed example\n]]>\n\n| Metric/' "$REPO/$TABLE_REL" ;;
+    html-block) perl -0777 -pi -e 's/\n\| Metric/\n<div>\n| Metric/; $_ .= "<\/div>\n"' "$REPO/$TABLE_REL" ;;
+    indented-code) perl -pi -e 's/^\|/    |/' "$REPO/$TABLE_REL" ;;
+    no-header) perl -ni -e 'print unless /^\| (Metric|---)/' "$REPO/$TABLE_REL" ;;
+    header-anchor) perl -0777 -pi -e 's/\| Metric \| Definition \| Source \|/| Unplanned deployments caused by production incidents | Definition | Source |/; s/\n\| Incident deployment ratio[^\n]*\n/\n/' "$REPO/$TABLE_REL" ;;
+    no-red) : ;;
+  esac
+  local status='RED-baseline' observed='yes'
+  if [ "$label" = no-red ]; then status='semantic-control'; observed='no'; fi
+  printf '| Fixture definition table %s | `downstream-executor` | behavioral-evidence: %s; observed-failure: %s; result-class: failure; firing-path: file:%s#%s | `updated` | `product-rd-workflow/SKILL.md` definition correction |\n' "$label" "$status" "$observed" "$firing_path" "$anchor" >> "$REGISTER"
+  commit_case "definition table $label"
+  run_gate
+  assert_rc "$rc" "$expected" "definition table $label"
+  if [ "$expected" = 1 ]; then
+    if [ "$label" = no-red ]; then
+      assert_contains 'impact_chain_behavior_evidence_missing' "$out" "definition table $label: $out"
+    else
+      assert_contains 'impact_chain_firing_path_missing' "$out" "definition table $label: $out"
+    fi
+  fi
+}
+definition_table_case accepted 0
+definition_table_case closed-cdata 0
+for definition_control in surviving-anchor unchanged-table foreign-owner duplicate inline-comment multiline-comment backtick-fence tilde-fence raw-html raw-html-open-line processing-instruction cdata declaration html-block indented-code no-header header-anchor no-red; do
+  definition_table_case "$definition_control" 1
+done
+
+# Evidence is not its own firing surface. Keep the anchor only in the locator
+# itself so uniqueness cannot accidentally reject the self-certifying row.
+new_case case-ref-definition-table-self-register
+printf '\nFixture bookkeeping note, with no new enforcing rule.\n' >> "$REPO/skills/skill-extraction-workflow/references/validation-and-landing.md"
+printf '\n| Rule | Owner | Behavior | Status | Evidence |\n| --- | --- | --- | --- | --- |\n' >> "$REGISTER"
+printf '| Fixture self-citing table | `downstream-executor` | behavioral-evidence: RED-baseline; observed-failure: yes; result-class: failure; firing-path: file:skills/skill-extraction-workflow/references/source-register.md#SELF-REGISTER-DEFINITION-ANCHOR | updated | `skill-extraction-workflow/SKILL.md` bookkeeping edit |\n' >> "$REGISTER"
+commit_case "source register cannot certify its own firing path"
+run_gate
+assert_rc "$rc" 1 "source register must not be its own firing surface"
+assert_contains 'impact_chain_firing_path_missing' "$out" "self-register refusal must name the firing-path boundary"
+
 # A purely DESCRIPTIVE list line ("always exposes" — no imperative/prohibitive
 # verb) is not an enforcing rule; the widened verb list must not admit it.
 new_case case-ref-descriptive-always-firing-path
@@ -1583,6 +1656,6 @@ assert_rc "$rc" 1 "a directory masquerading as SKILL.md must not read as a prese
 assert_contains "platform-observability/SKILL.md" "$out" "the masqueraded owner must be named"
 
 assert_rc "$full_check_runs" 1 "fixture suite must retain exactly one full checker wiring case"
-assert_rc "$gate_runs" 97 "all remaining impact-chain fixtures must run the standalone gate"
+assert_rc "$gate_runs" 118 "all remaining impact-chain fixtures must run the standalone gate"
 
 echo "test_check_ccl_impact_chain_refscripts: ok"