halfcycle 0.4.13 → 0.4.15

package/bin/pre-tool-use-filter.sh

@@ -7,8 +7,134 @@ halfcycle_pt_skip() {
   local hc_t=${EPOCHREALTIME:-} hc_status
   [ "${BASH_VERSINFO[0]:-0}" -ge 5 ] || return 1
   case $hc_t in [0-9]*[.,][0-9][0-9][0-9]*) ;; *) return 1 ;; esac
+  hc_pt_live_text= hc_pt_live_sid= hc_pt_live_agent= hc_pt_live_dir=
+  hc_pt_own_file= hc_pt_own_agent_id= hc_pt_own_tool_use_id=
   halfcycle_pt_quiet || return 1
-  halfcycle_pt_time_line "$hc_t"
+  halfcycle_pt_live || return 1
+  halfcycle_pt_own_copy || return 1
+  halfcycle_pt_own_read || return 1
+  halfcycle_pt_time_line "$hc_t" || return 1
+  halfcycle_pt_own_write "$hc_t"
+  return 0
+}
+halfcycle_pt_own_read() {
+  local LC_ALL=C hc_val hc_dir hc_re='^[A-Za-z0-9_-]{1,128}$'
+  halfcycle_pt_string tool_name || return 1
+  case $hc_val in
+    Bash|PowerShell) ;;
+    *) return 0 ;;
+  esac
+  halfcycle_pt_string session_id
+  case $? in 0) ;; 1) return 0 ;; *) return 1 ;; esac
+  [[ $hc_val =~ $hc_re ]] || return 0
+  hc_dir=${TMPDIR:-/tmp}
+  while [ "${hc_dir%/}" != "$hc_dir" ]; do hc_dir=${hc_dir%/}; done
+  hc_pt_own_file=$hc_dir/halfcycle-own-$hc_val.jsonl
+  halfcycle_pt_optional 'agent_id' || return 1
+  hc_pt_own_agent_id=$hc_val
+  halfcycle_pt_optional 'tool_use_id' || return 1
+  hc_pt_own_tool_use_id=$hc_val
+  return 0
+}
+halfcycle_pt_own_write() {
+  local LC_ALL=C hc_at hc_line
+  [ -n "$hc_pt_own_file" ] || return 0
+  halfcycle_pt_stamp "$1" || return 0
+  printf -v hc_line '{"at":"%s","kind":"shell","agent":%s,"toolUse":%s}' "$hc_at" "$hc_pt_own_agent_id" "$hc_pt_own_tool_use_id" || return 0
+  umask 077
+  { printf '%s\n' "$hc_line" >> "$hc_pt_own_file"; } 2>/dev/null
+  return 0
+}
+halfcycle_pt_stamp() {
+  local hc_secs hc_frac
+  hc_secs=${1%%[.,]*}
+  hc_frac=${1#*[.,]}
+  TZ=UTC0 printf -v hc_at '%(%Y-%m-%dT%H:%M:%S)T' "$hc_secs" || return 1
+  hc_at=$hc_at.${hc_frac:0:3}Z
+}
+halfcycle_pt_live() {
+  local LC_ALL=C hc_val hc_sid hc_agent= hc_cwd hc_dir hc_file hc_text= hc_ng=0 hc_re='^[A-Za-z0-9_-]{1,128}$'
+  local -a hc_files
+  halfcycle_pt_string session_id
+  case $? in 0) hc_sid=$hc_val ;; 1) return 0 ;; *) return 1 ;; esac
+  [[ $hc_sid =~ $hc_re ]] || return 0
+  halfcycle_pt_string agent_id
+  case $? in 0) hc_agent=$hc_val ;; 1) ;; *) return 1 ;; esac
+  if [ -n "$hc_agent" ]; then
+    [[ $hc_agent =~ $hc_re ]] || return 0
+    hc_agent=-$hc_agent
+  fi
+  halfcycle_pt_string cwd
+  case $? in 0) hc_cwd=$hc_val ;; 1) return 0 ;; *) return 1 ;; esac
+  [ -n "$hc_cwd" ] || return 0
+  case $hc_cwd in *'\'*|*[$'\n\r']*) return 1 ;; esac
+  hc_dir=${TMPDIR:-/tmp}
+  while [ "${hc_dir%/}" != "$hc_dir" ]; do hc_dir=${hc_dir%/}; done
+  shopt -q nullglob && hc_ng=1
+  shopt -s nullglob
+  hc_files=("$hc_dir"/halfcycle-live-"$hc_sid"/halfcycle-session-[0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z]-"$hc_sid".live"$hc_agent")
+  [ "$hc_ng" = 1 ] || shopt -u nullglob
+  [ "${#hc_files[@]}" -eq 1 ] || return 1
+  hc_file=$hc_dir/${hc_files[0]##*/}
+  IFS= read -r -d '' hc_text < "$hc_file" 2>/dev/null
+  [ "${hc_text%%$'\n'*}" = "$hc_cwd" ] || return 1
+  { printf '%s' "$hc_text" > "$hc_file"; } 2>/dev/null || return 1
+  hc_pt_live_text=$hc_text hc_pt_live_sid=$hc_sid hc_pt_live_agent=${hc_agent#-} hc_pt_live_dir=$hc_dir
+  return 0
+}
+halfcycle_pt_own_copy() {
+  local LC_ALL=C hc_val hc_top hc_rest hc_d hc_f hc_text= hc_ng=0 hc_others=0
+  local -a hc_files
+  halfcycle_pt_string tool_name || return 1
+  case $hc_val in
+    Write|Edit|MultiEdit) ;;
+    *) return 0 ;;
+  esac
+  halfcycle_pt_string file_path || return 1
+  case $hc_val in /*) ;; *) return 1 ;; esac
+  case $hc_val in *'\'*|*[$'\n\r']*) return 1 ;; esac
+  hc_rest=${hc_pt_live_text#*$'\n'}
+  hc_top=${hc_rest%%$'\n'*}
+  case $hc_top in /?*) ;; *) return 1 ;; esac
+  shopt -q nullglob && hc_ng=1
+  shopt -s nullglob
+  hc_files=("$hc_pt_live_dir"/halfcycle-live-"$hc_pt_live_sid"/halfcycle-session-[0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z]-"$hc_pt_live_sid".live-*)
+  [ "$hc_ng" = 1 ] || shopt -u nullglob
+  for hc_f in "${hc_files[@]}"; do
+    if [ -n "$hc_pt_live_agent" ]; then
+      case $hc_f in *.live-"$hc_pt_live_agent") continue ;; esac
+    fi
+    hc_others=1
+  done
+  case $hc_val in
+    "$hc_top"/?*) ;;
+    *) [ -z "$hc_pt_live_agent" ] && [ "$hc_others" = 0 ] && return 0; return 1 ;;
+  esac
+  hc_rest=${hc_val#"$hc_top"/}
+  case /$hc_rest/ in *//*|*/./*|*/../*) return 1 ;; esac
+  hc_d=$hc_top
+  while :; do
+    case $hc_rest in */*) ;; *) break ;; esac
+    hc_d=$hc_d/${hc_rest%%/*}
+    hc_rest=${hc_rest#*/}
+    [ -h "$hc_d" ] && return 1
+    [ -d "$hc_d" ] || break
+    { [ -e "$hc_d/.git" ] || [ -h "$hc_d/.git" ]; } && return 1
+  done
+  [ -z "$hc_pt_live_agent" ] && return 0
+  [ "$hc_others" = 0 ] && return 0
+  shopt -q nullglob && hc_ng=1
+  shopt -s nullglob
+  hc_files=("$hc_pt_live_dir"/halfcycle-live-"$hc_pt_live_sid"/halfcycle-session-[0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z][0-9a-z]-"$hc_pt_live_sid".live)
+  [ "$hc_ng" = 1 ] || shopt -u nullglob
+  [ "${#hc_files[@]}" -eq 1 ] || return 1
+  IFS= read -r -d '' hc_text < "$hc_pt_live_dir/${hc_files[0]##*/}" 2>/dev/null
+  case $hc_text in *$'\n'*$'\n'*) ;; *) return 1 ;; esac
+  hc_text=${hc_text#*$'\n'}
+  hc_text=${hc_text%%$'\n'*}
+  [ -n "$hc_text" ] || return 1
+  [ "$hc_text" = "$hc_top" ] && return 1
+  return 0
 }
 halfcycle_pt_quiet() {
   local LC_ALL=C hc_status hc_ext=0
@@ -29,7 +155,6 @@ halfcycle_pt_quiet_input() {
   case $hc_input in *'"tool_input":{'*) ;; *) return 1 ;; esac
   halfcycle_pt_once '"tool_input"' || return 1
   case $hc_tool in
-    NotebookEdit|Agent) return 0 ;;
     Bash)
       halfcycle_pt_string command
       case $? in 1) return 0 ;; 2) return 1 ;; esac
@@ -225,6 +350,7 @@ halfcycle_pt_records() {
   halfcycle_pt_holds 'features' $'f?(\x01)e?(\x01)a?(\x01)t?(\x01)u?(\x01)r?(\x01)e?(\x01)s' && return 1
   halfcycle_pt_holds 'decisions' $'d?(\x01)e?(\x01)c?(\x01)i?(\x01)s?(\x01)i?(\x01)o?(\x01)n?(\x01)s' && return 1
   halfcycle_pt_holds 'build-tasks.json' $'b?(\x01)u?(\x01)i?(\x01)l?(\x01)d?(\x01)-?(\x01)t?(\x01)a?(\x01)s?(\x01)k?(\x01)s?(\x01).?(\x01)j?(\x01)s?(\x01)o?(\x01)n' && return 1
+  halfcycle_pt_holds 'task-plan.json' $'t?(\x01)a?(\x01)s?(\x01)k?(\x01)-?(\x01)p?(\x01)l?(\x01)a?(\x01)n?(\x01).?(\x01)j?(\x01)s?(\x01)o?(\x01)n' && return 1
   halfcycle_pt_holds 'build-records' $'b?(\x01)u?(\x01)i?(\x01)l?(\x01)d?(\x01)-?(\x01)r?(\x01)e?(\x01)c?(\x01)o?(\x01)r?(\x01)d?(\x01)s' && return 1
   halfcycle_pt_holds '.claude' $'.?(\x01)c?(\x01)l?(\x01)a?(\x01)u?(\x01)d?(\x01)e' && return 1
   return 0
@@ -286,6 +412,11 @@ halfcycle_pt_branch() {
   local hc_dir hc_dotgit hc_gitdir hc_text hc_line hc_ptr hc_path
   hc_branch=null
   case $1 in /*) ;; *) return 0 ;; esac
+  hc_dir=$1
+  while [ -n "$hc_dir" ] && [ "$hc_dir" != / ]; do
+    [ -L "$hc_dir" ] && return 1
+    hc_dir=${hc_dir%/*}
+  done
   halfcycle_pt_resolve "$1"
   hc_dir=$hc_path
   [ -d "$hc_dir" ] || return 0
@@ -364,10 +495,7 @@ halfcycle_pt_time_line() {
     case $hc_folder in *[$'\x01'-$'\x1f']*|*'\'*|*'"'*) return 1 ;; esac
   fi
   halfcycle_pt_branch "$hc_folder" || return 1
-  hc_secs=${1%%[.,]*}
-  hc_frac=${1#*[.,]}
-  TZ=UTC0 printf -v hc_at '%(%Y-%m-%dT%H:%M:%S)T' "$hc_secs" || return 1
-  hc_at=$hc_at.${hc_frac:0:3}Z
+  halfcycle_pt_stamp "$1" || return 1
   printf -v hc_line '{"at":"%s","event":"action","session":%s,"agent":%s,"folder":"%s","branch":%s,"transcript":%s,"toolUse":%s}' "$hc_at" "$hc_f_session_id" "$hc_f_agent_id" "$hc_folder" "$hc_branch" "$hc_f_transcript_path" "$hc_f_tool_use_id"
   hc_dir=$hc_home/.halfcycle/engagements/$hc_id/time-log
   umask 077

package/commands/agent-teams-orchestration.md

@@ -2,7 +2,7 @@
 description: Take a plan that already exists and drive ALL of it through to done across several workers at once, rather than handing out the pieces one at a time
 ---
 
-Resolve `/agent-teams-orchestration` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. At one of those boundaries, and at most once per run, point them at this project's own page on the web and say what is there: how the project is going, the agents working on it once there are any, and their other projects alongside it. Use the address this install already records for the project's page rather than building one from an example, and give them the address itself — a page they are told about but cannot reach is worse than not mentioning it. Some steps of the Halfcycle method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. Everything you say to the person is in plain words. Name the Halfcycle method the first time and say what it is in the same breath — the process that will guide the two of you through building this — because bare "the method" means nothing to someone who has not met it. After that, talk about their product and never about how any of this works underneath: no paths or files of ours, no hooks, settings, commands, layers or step ids. Name a stage by its step's name, the professional's term spelled out, then say plainly what it means and give a short phrase they can say to start it, and never Halfcycle's own machinery as the subject of a sentence. Say what now exists, what it is for, and what you need from them, in their terms. The one thing you never soften and never leave out is what did NOT happen — say that plainly too. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
+Resolve `/agent-teams-orchestration` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. At one of those boundaries, and at most once per run, point them at this project's own page on the web and say what is there: how the project is going, the agents working on it once there are any, and their other projects alongside it. Use the address this install already records for the project's page rather than building one from an example, and give them the address itself — a page they are told about but cannot reach is worse than not mentioning it. Some steps of the Halfcycle method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. Everything you say to the person is in plain words. Name the Halfcycle method the first time and say what it is in the same breath — the process that will guide the two of you through building this — because bare "the method" means nothing to someone who has not met it. After that, talk about their product and never about how any of this works underneath: no paths or files of ours, no hooks, settings, commands, layers or step ids. Name a stage by its step's name, the professional's term spelled out, then say plainly what it means and offer to start it, as a question, and start it when they say yes; where only the owner can give an approval, say so plainly and say how they give it, and never Halfcycle's own machinery as the subject of a sentence. Say what now exists, what it is for, and what you need from them, in their terms. The one thing you never soften and never leave out is what did NOT happen — say that plainly too. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
 
 If resolution fails, report exactly this and stop:
 

package/commands/consistency-check.md

@@ -2,7 +2,7 @@
 description: Check a drafted feature spec against the invariants and its adjacent specs, from a session that did not write it
 ---
 
-Resolve `/consistency-check` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. At one of those boundaries, and at most once per run, point them at this project's own page on the web and say what is there: how the project is going, the agents working on it once there are any, and their other projects alongside it. Use the address this install already records for the project's page rather than building one from an example, and give them the address itself — a page they are told about but cannot reach is worse than not mentioning it. Some steps of the Halfcycle method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. Everything you say to the person is in plain words. Name the Halfcycle method the first time and say what it is in the same breath — the process that will guide the two of you through building this — because bare "the method" means nothing to someone who has not met it. After that, talk about their product and never about how any of this works underneath: no paths or files of ours, no hooks, settings, commands, layers or step ids. Name a stage by its step's name, the professional's term spelled out, then say plainly what it means and give a short phrase they can say to start it, and never Halfcycle's own machinery as the subject of a sentence. Say what now exists, what it is for, and what you need from them, in their terms. The one thing you never soften and never leave out is what did NOT happen — say that plainly too. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
+Resolve `/consistency-check` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. At one of those boundaries, and at most once per run, point them at this project's own page on the web and say what is there: how the project is going, the agents working on it once there are any, and their other projects alongside it. Use the address this install already records for the project's page rather than building one from an example, and give them the address itself — a page they are told about but cannot reach is worse than not mentioning it. Some steps of the Halfcycle method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. Everything you say to the person is in plain words. Name the Halfcycle method the first time and say what it is in the same breath — the process that will guide the two of you through building this — because bare "the method" means nothing to someone who has not met it. After that, talk about their product and never about how any of this works underneath: no paths or files of ours, no hooks, settings, commands, layers or step ids. Name a stage by its step's name, the professional's term spelled out, then say plainly what it means and offer to start it, as a question, and start it when they say yes; where only the owner can give an approval, say so plainly and say how they give it, and never Halfcycle's own machinery as the subject of a sentence. Say what now exists, what it is for, and what you need from them, in their terms. The one thing you never soften and never leave out is what did NOT happen — say that plainly too. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
 
 If resolution fails, report exactly this and stop:
 

package/commands/context-update.md

@@ -2,7 +2,7 @@
 description: Route recent changes into the repo's context surfaces
 ---
 
-Resolve `/context-update` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. At one of those boundaries, and at most once per run, point them at this project's own page on the web and say what is there: how the project is going, the agents working on it once there are any, and their other projects alongside it. Use the address this install already records for the project's page rather than building one from an example, and give them the address itself — a page they are told about but cannot reach is worse than not mentioning it. Some steps of the Halfcycle method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. Everything you say to the person is in plain words. Name the Halfcycle method the first time and say what it is in the same breath — the process that will guide the two of you through building this — because bare "the method" means nothing to someone who has not met it. After that, talk about their product and never about how any of this works underneath: no paths or files of ours, no hooks, settings, commands, layers or step ids. Name a stage by its step's name, the professional's term spelled out, then say plainly what it means and give a short phrase they can say to start it, and never Halfcycle's own machinery as the subject of a sentence. Say what now exists, what it is for, and what you need from them, in their terms. The one thing you never soften and never leave out is what did NOT happen — say that plainly too. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
+Resolve `/context-update` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. At one of those boundaries, and at most once per run, point them at this project's own page on the web and say what is there: how the project is going, the agents working on it once there are any, and their other projects alongside it. Use the address this install already records for the project's page rather than building one from an example, and give them the address itself — a page they are told about but cannot reach is worse than not mentioning it. Some steps of the Halfcycle method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. Everything you say to the person is in plain words. Name the Halfcycle method the first time and say what it is in the same breath — the process that will guide the two of you through building this — because bare "the method" means nothing to someone who has not met it. After that, talk about their product and never about how any of this works underneath: no paths or files of ours, no hooks, settings, commands, layers or step ids. Name a stage by its step's name, the professional's term spelled out, then say plainly what it means and offer to start it, as a question, and start it when they say yes; where only the owner can give an approval, say so plainly and say how they give it, and never Halfcycle's own machinery as the subject of a sentence. Say what now exists, what it is for, and what you need from them, in their terms. The one thing you never soften and never leave out is what did NOT happen — say that plainly too. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
 
 If resolution fails, report exactly this and stop:
 

package/commands/halfcycle-design.md

@@ -2,7 +2,7 @@
 description: Work out what the product is — the design journey to a PRD and phases
 ---
 
-Resolve `/halfcycle-design` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. At one of those boundaries, and at most once per run, point them at this project's own page on the web and say what is there: how the project is going, the agents working on it once there are any, and their other projects alongside it. Use the address this install already records for the project's page rather than building one from an example, and give them the address itself — a page they are told about but cannot reach is worse than not mentioning it. Some steps of the Halfcycle method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. Everything you say to the person is in plain words. Name the Halfcycle method the first time and say what it is in the same breath — the process that will guide the two of you through building this — because bare "the method" means nothing to someone who has not met it. After that, talk about their product and never about how any of this works underneath: no paths or files of ours, no hooks, settings, commands, layers or step ids. Name a stage by its step's name, the professional's term spelled out, then say plainly what it means and give a short phrase they can say to start it, and never Halfcycle's own machinery as the subject of a sentence. Say what now exists, what it is for, and what you need from them, in their terms. The one thing you never soften and never leave out is what did NOT happen — say that plainly too. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
+Resolve `/halfcycle-design` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. At one of those boundaries, and at most once per run, point them at this project's own page on the web and say what is there: how the project is going, the agents working on it once there are any, and their other projects alongside it. Use the address this install already records for the project's page rather than building one from an example, and give them the address itself — a page they are told about but cannot reach is worse than not mentioning it. Some steps of the Halfcycle method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. Everything you say to the person is in plain words. Name the Halfcycle method the first time and say what it is in the same breath — the process that will guide the two of you through building this — because bare "the method" means nothing to someone who has not met it. After that, talk about their product and never about how any of this works underneath: no paths or files of ours, no hooks, settings, commands, layers or step ids. Name a stage by its step's name, the professional's term spelled out, then say plainly what it means and offer to start it, as a question, and start it when they say yes; where only the owner can give an approval, say so plainly and say how they give it, and never Halfcycle's own machinery as the subject of a sentence. Say what now exists, what it is for, and what you need from them, in their terms. The one thing you never soften and never leave out is what did NOT happen — say that plainly too. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
 
 If resolution fails, report exactly this and stop:
 

package/commands/halfcycle-setup.md

@@ -2,7 +2,7 @@
 description: Set up a repository for a Halfcycle engagement
 ---
 
-Resolve `/halfcycle-setup` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. At one of those boundaries, and at most once per run, point them at this project's own page on the web and say what is there: how the project is going, the agents working on it once there are any, and their other projects alongside it. Use the address this install already records for the project's page rather than building one from an example, and give them the address itself — a page they are told about but cannot reach is worse than not mentioning it. Some steps of the Halfcycle method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. Everything you say to the person is in plain words. Name the Halfcycle method the first time and say what it is in the same breath — the process that will guide the two of you through building this — because bare "the method" means nothing to someone who has not met it. After that, talk about their product and never about how any of this works underneath: no paths or files of ours, no hooks, settings, commands, layers or step ids. Name a stage by its step's name, the professional's term spelled out, then say plainly what it means and give a short phrase they can say to start it, and never Halfcycle's own machinery as the subject of a sentence. Say what now exists, what it is for, and what you need from them, in their terms. The one thing you never soften and never leave out is what did NOT happen — say that plainly too. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
+Resolve `/halfcycle-setup` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. At one of those boundaries, and at most once per run, point them at this project's own page on the web and say what is there: how the project is going, the agents working on it once there are any, and their other projects alongside it. Use the address this install already records for the project's page rather than building one from an example, and give them the address itself — a page they are told about but cannot reach is worse than not mentioning it. Some steps of the Halfcycle method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. Everything you say to the person is in plain words. Name the Halfcycle method the first time and say what it is in the same breath — the process that will guide the two of you through building this — because bare "the method" means nothing to someone who has not met it. After that, talk about their product and never about how any of this works underneath: no paths or files of ours, no hooks, settings, commands, layers or step ids. Name a stage by its step's name, the professional's term spelled out, then say plainly what it means and offer to start it, as a question, and start it when they say yes; where only the owner can give an approval, say so plainly and say how they give it, and never Halfcycle's own machinery as the subject of a sentence. Say what now exists, what it is for, and what you need from them, in their terms. The one thing you never soften and never leave out is what did NOT happen — say that plainly too. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
 
 If resolution fails, report whichever applies and stop:
 

package/commands/stack-assembly-worker.md

@@ -2,7 +2,7 @@
 description: Verify a phase's assembled stack comes up end to end
 ---
 
-Resolve `/stack-assembly-worker` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. At one of those boundaries, and at most once per run, point them at this project's own page on the web and say what is there: how the project is going, the agents working on it once there are any, and their other projects alongside it. Use the address this install already records for the project's page rather than building one from an example, and give them the address itself — a page they are told about but cannot reach is worse than not mentioning it. Some steps of the Halfcycle method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. Everything you say to the person is in plain words. Name the Halfcycle method the first time and say what it is in the same breath — the process that will guide the two of you through building this — because bare "the method" means nothing to someone who has not met it. After that, talk about their product and never about how any of this works underneath: no paths or files of ours, no hooks, settings, commands, layers or step ids. Name a stage by its step's name, the professional's term spelled out, then say plainly what it means and give a short phrase they can say to start it, and never Halfcycle's own machinery as the subject of a sentence. Say what now exists, what it is for, and what you need from them, in their terms. The one thing you never soften and never leave out is what did NOT happen — say that plainly too. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
+Resolve `/stack-assembly-worker` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. At one of those boundaries, and at most once per run, point them at this project's own page on the web and say what is there: how the project is going, the agents working on it once there are any, and their other projects alongside it. Use the address this install already records for the project's page rather than building one from an example, and give them the address itself — a page they are told about but cannot reach is worse than not mentioning it. Some steps of the Halfcycle method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. Everything you say to the person is in plain words. Name the Halfcycle method the first time and say what it is in the same breath — the process that will guide the two of you through building this — because bare "the method" means nothing to someone who has not met it. After that, talk about their product and never about how any of this works underneath: no paths or files of ours, no hooks, settings, commands, layers or step ids. Name a stage by its step's name, the professional's term spelled out, then say plainly what it means and offer to start it, as a question, and start it when they say yes; where only the owner can give an approval, say so plainly and say how they give it, and never Halfcycle's own machinery as the subject of a sentence. Say what now exists, what it is for, and what you need from them, in their terms. The one thing you never soften and never leave out is what did NOT happen — say that plainly too. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
 
 If resolution fails, report exactly this and stop:
 

package/commands/task-execution.md

@@ -2,7 +2,7 @@
 description: Do ONE piece of the planned work, on its own — not the whole plan
 ---
 
-Resolve `/task-execution` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. At one of those boundaries, and at most once per run, point them at this project's own page on the web and say what is there: how the project is going, the agents working on it once there are any, and their other projects alongside it. Use the address this install already records for the project's page rather than building one from an example, and give them the address itself — a page they are told about but cannot reach is worse than not mentioning it. Some steps of the Halfcycle method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. Everything you say to the person is in plain words. Name the Halfcycle method the first time and say what it is in the same breath — the process that will guide the two of you through building this — because bare "the method" means nothing to someone who has not met it. After that, talk about their product and never about how any of this works underneath: no paths or files of ours, no hooks, settings, commands, layers or step ids. Name a stage by its step's name, the professional's term spelled out, then say plainly what it means and give a short phrase they can say to start it, and never Halfcycle's own machinery as the subject of a sentence. Say what now exists, what it is for, and what you need from them, in their terms. The one thing you never soften and never leave out is what did NOT happen — say that plainly too. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
+Resolve `/task-execution` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. At one of those boundaries, and at most once per run, point them at this project's own page on the web and say what is there: how the project is going, the agents working on it once there are any, and their other projects alongside it. Use the address this install already records for the project's page rather than building one from an example, and give them the address itself — a page they are told about but cannot reach is worse than not mentioning it. Some steps of the Halfcycle method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. Everything you say to the person is in plain words. Name the Halfcycle method the first time and say what it is in the same breath — the process that will guide the two of you through building this — because bare "the method" means nothing to someone who has not met it. After that, talk about their product and never about how any of this works underneath: no paths or files of ours, no hooks, settings, commands, layers or step ids. Name a stage by its step's name, the professional's term spelled out, then say plainly what it means and offer to start it, as a question, and start it when they say yes; where only the owner can give an approval, say so plainly and say how they give it, and never Halfcycle's own machinery as the subject of a sentence. Say what now exists, what it is for, and what you need from them, in their terms. The one thing you never soften and never leave out is what did NOT happen — say that plainly too. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
 
 If resolution fails, report exactly this and stop:
 

package/commands/task-graph.md

@@ -2,7 +2,7 @@
 description: Break the next chunk of work into ordered pieces that can be handed out — what has to happen before what, and who could take each
 ---
 
-Resolve `/task-graph` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. At one of those boundaries, and at most once per run, point them at this project's own page on the web and say what is there: how the project is going, the agents working on it once there are any, and their other projects alongside it. Use the address this install already records for the project's page rather than building one from an example, and give them the address itself — a page they are told about but cannot reach is worse than not mentioning it. Some steps of the Halfcycle method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. Everything you say to the person is in plain words. Name the Halfcycle method the first time and say what it is in the same breath — the process that will guide the two of you through building this — because bare "the method" means nothing to someone who has not met it. After that, talk about their product and never about how any of this works underneath: no paths or files of ours, no hooks, settings, commands, layers or step ids. Name a stage by its step's name, the professional's term spelled out, then say plainly what it means and give a short phrase they can say to start it, and never Halfcycle's own machinery as the subject of a sentence. Say what now exists, what it is for, and what you need from them, in their terms. The one thing you never soften and never leave out is what did NOT happen — say that plainly too. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
+Resolve `/task-graph` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. At one of those boundaries, and at most once per run, point them at this project's own page on the web and say what is there: how the project is going, the agents working on it once there are any, and their other projects alongside it. Use the address this install already records for the project's page rather than building one from an example, and give them the address itself — a page they are told about but cannot reach is worse than not mentioning it. Some steps of the Halfcycle method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. Everything you say to the person is in plain words. Name the Halfcycle method the first time and say what it is in the same breath — the process that will guide the two of you through building this — because bare "the method" means nothing to someone who has not met it. After that, talk about their product and never about how any of this works underneath: no paths or files of ours, no hooks, settings, commands, layers or step ids. Name a stage by its step's name, the professional's term spelled out, then say plainly what it means and offer to start it, as a question, and start it when they say yes; where only the owner can give an approval, say so plainly and say how they give it, and never Halfcycle's own machinery as the subject of a sentence. Say what now exists, what it is for, and what you need from them, in their terms. The one thing you never soften and never leave out is what did NOT happen — say that plainly too. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
 
 If resolution fails, report exactly this and stop:
 

package/commands/write-spec.md

@@ -2,7 +2,7 @@
 description: Draft a Layer 4 feature spec
 ---
 
-Resolve `/write-spec` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. At one of those boundaries, and at most once per run, point them at this project's own page on the web and say what is there: how the project is going, the agents working on it once there are any, and their other projects alongside it. Use the address this install already records for the project's page rather than building one from an example, and give them the address itself — a page they are told about but cannot reach is worse than not mentioning it. Some steps of the Halfcycle method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. Everything you say to the person is in plain words. Name the Halfcycle method the first time and say what it is in the same breath — the process that will guide the two of you through building this — because bare "the method" means nothing to someone who has not met it. After that, talk about their product and never about how any of this works underneath: no paths or files of ours, no hooks, settings, commands, layers or step ids. Name a stage by its step's name, the professional's term spelled out, then say plainly what it means and give a short phrase they can say to start it, and never Halfcycle's own machinery as the subject of a sentence. Say what now exists, what it is for, and what you need from them, in their terms. The one thing you never soften and never leave out is what did NOT happen — say that plainly too. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
+Resolve `/write-spec` for this engagement's current state, execute what comes back, report that the step ran, and resolve again — repeating until the response says there is nothing left (`hasNextStep` false); pausing for a human answer is not the end of the run. Do not improvise the procedure. Say where things stand at the boundaries of the run — when it starts, when it moves to a new layer, and when it ends — rather than on every turn, and pause only where a step asks you to. At one of those boundaries, and at most once per run, point them at this project's own page on the web and say what is there: how the project is going, the agents working on it once there are any, and their other projects alongside it. Use the address this install already records for the project's page rather than building one from an example, and give them the address itself — a page they are told about but cannot reach is worse than not mentioning it. Some steps of the Halfcycle method are judged by Halfcycle rather than by this session, or need a person to do something outside this session, so a quiet run is not a claim that nothing was due — say so when a run ends. Everything you say to the person is in plain words. Name the Halfcycle method the first time and say what it is in the same breath — the process that will guide the two of you through building this — because bare "the method" means nothing to someone who has not met it. After that, talk about their product and never about how any of this works underneath: no paths or files of ours, no hooks, settings, commands, layers or step ids. Name a stage by its step's name, the professional's term spelled out, then say plainly what it means and offer to start it, as a question, and start it when they say yes; where only the owner can give an approval, say so plainly and say how they give it, and never Halfcycle's own machinery as the subject of a sentence. Say what now exists, what it is for, and what you need from them, in their terms. The one thing you never soften and never leave out is what did NOT happen — say that plainly too. If you are asked to jump ahead: when that is what comes next anyway, just do it; when Halfcycle refuses, relay its reason word for word and invent no procedure of your own; when it can be served but skips something, do it and say what is being skipped and what that costs. Coming back later is fine — a fresh session re-orients from what this project has recorded, so ask to carry on in plain words and you get the right next step and where things stand.
 
 If resolution fails, report exactly this and stop:
 

package/dist/bin.d.ts

@@ -15,6 +15,7 @@
  *   halfcycle draw architecture|phase <phase> — draw the architecture or a phase's pictures into docs/diagrams (`draw/`)
  *   halfcycle plan <phase> [--show]          — check a phase's plan and report it; list it (`plan.ts`)
  *   halfcycle review <phase> --show | --answer <part> "…" — list a phase's close review; answer a question (`review.ts`)
+ *   halfcycle prove <phase> <task> --label "…" (--before|--after) [-- <cmd>] — run a check once on this machine and record what it saw (`prove.ts`)
  *   halfcycle uninstall [--remove-credential] — take back what the installer wrote here
  *
  * NO `ci` VERB (T-25, operator decision 2026-09-22(c)) — `ci bind`/`ci unbind`

package/dist/bin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG"}
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG"}

package/dist/build-record/pair-io.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The file discipline every record-pair writer shares: exclusive create, the
+ * write-then-rename replace, and the no-half-pair create of a `.json` beside its `.md`.
+ *
+ * ONE COPY FOR TWO WRITERS. A phase's Build Record (`write.ts`, `writeRecordPair`) and
+ * a small change's record (`write-change.ts`, `writeChangeRecordPair`) write their pairs
+ * through these helpers, and `draw`'s three-file writer goes through the same seam, so
+ * there is one exclusive-create on disk, not one per writer. What each writer decides
+ * for itself is only what to do when a file is already in the way: the phase writer may
+ * replace its own earlier record, the small-change writer, whose record is write-once,
+ * never replaces.
+ *
+ * Nothing here builds a path. Every caller composes and checks its own paths before it
+ * hands them over (INV-023).
+ */
+/**
+ * The file operations a pair writer makes, behind one seam so a test can make
+ * the SECOND write fail and watch the first come back out. `createExclusive` opens
+ * with `wx` (never truncates an existing file) and removes what it created if the
+ * write itself fails; `rename` replaces in one step on the same filesystem.
+ *
+ * ONE SEAM FOR TEXT AND BYTES. `draw`'s three-file writer (`../draw/write.ts`) goes
+ * through this same seam with a PNG's bytes, so a string is written as UTF-8 and a
+ * byte array as itself.
+ */
+export interface RecordPairIo {
+    createExclusive(path: string, data: string | Uint8Array): void;
+    rename(from: string, to: string): void;
+}
+export declare const NODE_RECORD_PAIR_IO: RecordPairIo;
+/** Serialise a served record for the `.json`: 2-space indent, trailing newline. */
+export declare function serialiseServedRecord(rawRecord: unknown): string;
+/** Is `err` the file system saying the file is already there? */
+export declare function isEexist(err: unknown): boolean;
+/** The text at `path`, or `null` when it cannot be read as a file. */
+export declare function readIfPresent(path: string): string | null;
+/**
+ * Create both files of a pair exclusively, `.json` first. `created`: both are down.
+ * `exists`: one of the two was already there, and nothing this call created is left
+ * behind (a `.json` it created is removed again), so the caller's own replace rule
+ * decides from a clean state. Any other failure is thrown, with nothing left behind.
+ */
+export declare function createPairExclusive(io: RecordPairIo, jsonPath: string, jsonText: string, mdPath: string, mdText: string): 'created' | 'exists';
+/**
+ * Write `text` to `tmp` and rename it over `finalPath`. A `.tmp` left by an earlier
+ * crash is removed first and never read. On failure the temporary file is removed.
+ */
+export declare function replaceOne(io: RecordPairIo, tmp: string, finalPath: string, text: string): void;
+//# sourceMappingURL=pair-io.d.ts.map

package/dist/build-record/pair-io.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pair-io.d.ts","sourceRoot":"","sources":["../../src/build-record/pair-io.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY;IAC3B,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAAC;IAC/D,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;CACxC;AA2BD,eAAO,MAAM,mBAAmB,EAAE,YAGjC,CAAC;AAEF,mFAAmF;AACnF,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,CAEhE;AAED,iEAAiE;AACjE,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAE9C;AAED,sEAAsE;AACtE,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAMzD;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,YAAY,EAChB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,SAAS,GAAG,QAAQ,CAYtB;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAS/F"}

package/dist/build-record/render-change.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The Markdown half of a small change's record pair (feature `three-paths`, *The
+ * writer*): `renderChangeRecordMarkdown` turns a frozen `smallChangeRecordSchema` value
+ * into the `.md` written beside its `.json` under `docs/build-records/changes/`.
+ *
+ * A SMALL CHANGE IS NOT A PHASE, and its record never reads as one: no line here says
+ * approved, unapproved, or asks for an approval (three-paths AC6, INV-024). A small
+ * change carries no approval to give or to lack, so the words never appear.
+ *
+ * WHOSE WORDS ARE WHOSE (INV-025). What Halfcycle counted is under "What Halfcycle
+ * saw"; the agent's one line, a reviewer's finding, a diagnosis and a call are each
+ * marked as the agent's own. A change that ended without a count (stopped, or moved up
+ * by the person) says Halfcycle did not count it, never that nothing changed. A window
+ * with no recorded check run reads as not observed, never as nothing found (INV-021).
+ *
+ * Every string from the record is printed through the Build Record renderer's own
+ * escapers (`printRecordText` for a slot with a line of its own, `printStrictText` for
+ * a slot sharing a line), so record text cannot become markup. One home for that rule.
+ *
+ * SHIPS TO CLIENT DISK inside the CLI: no comment sits beside an object member.
+ */
+import type { SmallChangeRecord } from '@halfcycle/events';
+/** The `.md` of a small change's record. Pure: the same record renders the same text. */
+export declare function renderChangeRecordMarkdown(record: SmallChangeRecord): string;
+//# sourceMappingURL=render-change.d.ts.map

package/dist/build-record/render-change.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-change.d.ts","sourceRoot":"","sources":["../../src/build-record/render-change.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAsH3D,yFAAyF;AACzF,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CA4C5E"}

package/dist/build-record/render-v2.d.ts

@@ -16,10 +16,12 @@
  * bytes, whatever key order a database hands back.
  *
  * IT DOES NOT PARSE. The caller parses the record first; the type here is the
- * contract's own inferred type. Two of the contract's functions are imported at
+ * contract's own inferred type. Four of the contract's functions are imported at
  * runtime, because each is the one home of what it composes: `codeLinkLine`, the
- * code line every reader prints for a part, and `removalsOf`, the parts a closed
- * review leaves to take out of the system description. Neither is restated here.
+ * code line every reader prints for a part; `removalsOf`, the parts a closed
+ * review leaves to take out of the system description; `hasOwnerReview`, whether a
+ * record kept the owner's review (v3 and v4 did, v2 did not); and `keptPathOf`, the
+ * phase's path a v4 record kept. None is restated here, and no format is compared.
  * The one cross-half rule it relies
  * on — both halves describe the same closes, paired by `sequence` — it checks
  * itself and throws on, because printing a close without its other half would
@@ -77,8 +79,11 @@ export declare function latestCloseHeadline(record: BuildRecord): string;
  * learned an earlier round said something else).
  *
  * Render a parsed Build Record as markdown: v2's observed and attested halves, which
- * a v3 record carries unchanged, and for a v3 record the owner's review after the
- * latest close (RM1–RM3, feature `close-review-and-carry-drop`).
+ * a v3 or v4 record carries unchanged; for a v4 record its path; for a v3 or v4
+ * record the owner's review after the latest close (RM1–RM3, feature
+ * `close-review-and-carry-drop`); and for a v4 record alone the calls made without asking
+ * (C1–C5) and the owner's answers to checks Halfcycle never ran, after the review. An
+ * older record prints neither section, so its Markdown is unchanged.
  *
  * Throws, in client words, if the two halves describe different closes — which a
  * parsed record cannot do. Output uses `\n` only and ends in exactly one `\n`.

package/dist/build-record/render-v2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render-v2.d.ts","sourceRoot":"","sources":["../../src/build-record/render-v2.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAGL,KAAK,WAAW,EAKjB,MAAM,mBAAmB,CAAC;AA8J3B;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAepD;AAKD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CASpD;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOvD;AAgMD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAO/D;AAmRD;;;;;;;;;;;;GAYG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAyEvE"}
+{"version":3,"file":"render-v2.d.ts","sourceRoot":"","sources":["../../src/build-record/render-v2.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAmBL,KAAK,WAAW,EAQjB,MAAM,mBAAmB,CAAC;AA8J3B;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAepD;AAKD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CASpD;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOvD;AA2MD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAO/D;AAwVD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAgFvE"}

package/dist/build-record/write-change.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The small-change record pair writer (feature `three-paths`, *The writer*).
+ *
+ * A small change's record is not a phase's Build Record, so it never goes through
+ * `writeRecordPair`: it has its own folder, `docs/build-records/changes/`, its own
+ * renderer (`render-change.ts`) and a narrower replace rule.
+ *
+ * THE FILENAME COMES FROM THE CALLER'S `sortingId` ARGUMENT, never from the record
+ * (INV-023). The argument is checked as a UUID (`sortingIdSchema`, the contracts' one
+ * home of a change id) here, where every caller converges, before any path is made,
+ * so the CLI's own check is not the only one. `record.sortingId` is never read for a
+ * path: a record naming another change, or `../x`, still lands at the argument's name.
+ * After the join, every path, temporary ones included, is checked to be a plain file
+ * directly inside the folder, comparing two operands that move independently: the
+ * folder (from `repoRoot` and a constant) and the candidate (from the argument).
+ *
+ * WRITE-ONCE, SO NEVER REPLACED. The service freezes a small change's record once, so
+ * the same `.json` bytes already there are up to date (the `.md` is rendered again,
+ * so a renderer change never refuses the CLI's own pair), and anything else in the way
+ * is refused, naming the file. The exclusive create and the no-half-pair rule are the
+ * shared ones in `pair-io.ts`.
+ *
+ * All-or-nothing: the id is checked, every path asserted and both texts rendered
+ * before the folder is made or the first file created.
+ */
+import { type SmallChangeRecord } from '@halfcycle/events';
+import { type RecordPairIo } from './pair-io.js';
+/** The one output folder for small-change records, relative to the project root. */
+export declare const CHANGE_RECORD_DIR: string;
+/** A change id that cannot name a record file: refused before any path is made. */
+export declare class InvalidChangeIdError extends Error {
+    readonly id: unknown;
+    constructor(id: unknown);
+}
+/**
+ * Assert that a joined path is still a plain file directly inside `outDir`. Exported
+ * so a test can hand it a candidate outside the folder: no id that passes the UUID
+ * check can produce one, so only a direct call can tell this guard from a deleted one.
+ */
+export declare function assertInsideChangeDir(outDir: string, candidate: string, id: unknown): void;
+/**
+ * What `writeChangeRecordPair` did. `created`: neither file existed. `up-to-date`: the
+ * `.json` already held these exact bytes, and the `.md` was rendered again.
+ * `in-the-way`: something else is at one of the two paths; nothing was written and
+ * `path` names it.
+ */
+export type ChangeRecordPairResult = {
+    kind: 'created' | 'up-to-date';
+    jsonPath: string;
+    mdPath: string;
+} | {
+    kind: 'in-the-way';
+    path: string;
+};
+/**
+ * Write a small change's record pair into `docs/build-records/changes/`: the `.json`
+ * as the service sent it, the `.md` rendered from the parsed record.
+ *
+ * @throws InvalidChangeIdError when `sortingId` is not a change id.
+ * @throws the file system's own error when a write fails; nothing is left behind.
+ */
+export declare function writeChangeRecordPair(repoRoot: string, sortingId: string, rawRecord: unknown, record: SmallChangeRecord, io?: RecordPairIo): ChangeRecordPairResult;
+//# sourceMappingURL=write-change.d.ts.map

package/dist/build-record/write-change.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-change.d.ts","sourceRoot":"","sources":["../../src/build-record/write-change.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,OAAO,EAAmB,KAAK,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE5E,OAAO,EAML,KAAK,YAAY,EAClB,MAAM,cAAc,CAAC;AAEtB,oFAAoF;AACpF,eAAO,MAAM,iBAAiB,QAA2C,CAAC;AAE1E,mFAAmF;AACnF,qBAAa,oBAAqB,SAAQ,KAAK;IACjC,QAAQ,CAAC,EAAE,EAAE,OAAO;gBAAX,EAAE,EAAE,OAAO;CAIjC;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,GAAG,IAAI,CAI1F;AAED;;;;;GAKG;AACH,MAAM,MAAM,sBAAsB,GAC9B;IAAE,IAAI,EAAE,SAAS,GAAG,YAAY,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACpE;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzC;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,OAAO,EAClB,MAAM,EAAE,iBAAiB,EACzB,EAAE,GAAE,YAAkC,GACrC,sBAAsB,CA0BxB"}

package/dist/build-record/write.d.ts

@@ -25,6 +25,7 @@
  * before the `mkdirSync` and the first create, so a refused record leaves no file
  * and no empty directory behind.
  */
+import { NODE_RECORD_PAIR_IO, serialiseServedRecord, type RecordPairIo } from './pair-io.js';
 import { type BuildRecord } from '@halfcycle/events';
 /** The one and only output directory (relative to the target repo root). */
 export declare const BUILD_RECORD_DIR: string;
@@ -43,20 +44,11 @@ export declare const BUILD_RECORD_DIR: string;
  */
 export declare function assertInsideOutDir(outDir: string, candidate: string, identity: unknown): void;
 /**
- * The file operations `writeRecordPair` makes, behind one seam so a test can make
- * the SECOND write fail and watch the first come back out. `createExclusive` opens
- * with `wx` (never truncates an existing file) and removes what it created if the
- * write itself fails; `rename` replaces in one step on the same filesystem.
- *
- * ONE SEAM FOR TEXT AND BYTES. `draw`'s three-file writer (`../draw/write.ts`) goes
- * through this same seam with a PNG's bytes, so a string is written as UTF-8 and a
- * byte array as itself, and there is one exclusive-create on disk, not two.
+ * The shared file discipline (`pair-io.ts`): one exclusive-create, one replace and one
+ * no-half-pair create for this writer and the small-change writer. Re-exported so the
+ * callers that have always imported them from here keep doing so.
  */
-export interface RecordPairIo {
-    createExclusive(path: string, data: string | Uint8Array): void;
-    rename(from: string, to: string): void;
-}
-export declare const NODE_RECORD_PAIR_IO: RecordPairIo;
+export { NODE_RECORD_PAIR_IO, serialiseServedRecord, type RecordPairIo };
 /**
  * What `writeRecordPair` did. `created`: neither file existed. `up-to-date`: the
  * `.json` already held these exact bytes, and the `.md` was rendered again.
@@ -72,8 +64,6 @@ export type RecordPairResult = {
     kind: 'in-the-way';
     path: string;
 };
-/** Serialise a served record for the `.json`: 2-space indent, trailing newline. */
-export declare function serialiseServedRecord(rawRecord: unknown): string;
 /**
  * Write a phase's Build Record pair into `docs/build-records/`: the `.json` as the
  * service sent it, and the `.md` rendered from the parsed record.

package/dist/build-record/write.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../src/build-record/write.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAcH,OAAO,EAKL,KAAK,WAAW,EACjB,MAAM,mBAAmB,CAAC;AAE3B,4EAA4E;AAC5E,eAAO,MAAM,gBAAgB,QAAgC,CAAC;AAE9D;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI,CAM7F;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY;IAC3B,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAAC;IAC/D,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;CACxC;AA2BD,eAAO,MAAM,mBAAmB,EAAE,YAGjC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,IAAI,EAAE,SAAS,GAAG,YAAY,GAAG,UAAU,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACjF;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzC,mFAAmF;AACnF,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,CAEhE;AA0CD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,OAAO,EAClB,MAAM,EAAE,WAAW,EACnB,EAAE,GAAE,YAAkC,GACrC,gBAAgB,CAyDlB"}
+{"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../src/build-record/write.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAKH,OAAO,EACL,mBAAmB,EAInB,qBAAqB,EACrB,KAAK,YAAY,EAClB,MAAM,cAAc,CAAC;AACtB,OAAO,EAKL,KAAK,WAAW,EACjB,MAAM,mBAAmB,CAAC;AAE3B,4EAA4E;AAC5E,eAAO,MAAM,gBAAgB,QAAgC,CAAC;AAE9D;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI,CAM7F;AAED;;;;GAIG;AACH,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,KAAK,YAAY,EAAE,CAAC;AAEzE;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,IAAI,EAAE,SAAS,GAAG,YAAY,GAAG,UAAU,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACjF;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AA8BzC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,OAAO,EAClB,MAAM,EAAE,WAAW,EACnB,EAAE,GAAE,YAAkC,GACrC,gBAAgB,CAkDlB"}