@synity/bitrix-skills 1.3.0

package/src/features/task-sync/assets/scripts/lib/bitrix-lib.sh

@@ -0,0 +1,540 @@
+#!/bin/bash
+# Shared Bitrix REST helpers for Claude Code hooks
+# Requires: bash, awk, curl, jq (POSIX awk — works on macOS BSD, Linux GNU, Windows Git Bash/WSL)
+# Env: BITRIX_WEBHOOK_URL (e.g. https://xxx.bitrix24.com/rest/1/token123/)
+#
+# API notes (MCP-DERIVED: bitrix-dev-mcp @ 2026-05-09; verified on portal 106 @ 2026-05-10):
+#   - tasks.task.chat.message.send  → REST v3, requires /rest/api/<user>/<token>/ URL.
+#                                     b24_call auto-rewrites URL when method matches v3 pattern.
+#                                     Bitrix renders task chat with BB code, NOT markdown.
+#                                     Use [b]bold[/b], [br], [disk=ID], [user=ID], [code]…[/code].
+#   - tasks.task.startTimer/pauseTimer → REST v2. NOT used: noisy (one system msg per skill).
+#                                     Replaced by single retroactive task.elapseditem.add at Stop.
+#   - task.elapseditem.add (legacy) → WORKS on this portal. ARFIELDS:{SECONDS,COMMENT_TEXT}.
+#                                     v3 tasks.task.elapsedtime.add returns error 100 — DO NOT USE.
+#   - task.commentitem.add          → posts to same dialog as chat (single channel on portal 106).
+#                                     Switching API does NOT separate channels — reduce noise instead.
+#   - batch                         → up to 50 cmds, supports $result[cmd] chaining
+
+# Cross-platform tmp dir (TMPDIR set on macOS/Windows, fallback /tmp on Linux)
+SESSION_DIR="${TMPDIR:-/tmp}/claude-b24"
+SESSION_DIR="${SESSION_DIR%/}"
+mkdir -p "$SESSION_DIR"
+
+# Preflight: warn once per session if required tools missing.
+# Hooks must NOT block the user — print to stderr and continue silently.
+_b24_preflight_done=0
+_b24_preflight() {
+  [[ "$_b24_preflight_done" == "1" ]] && return 0
+  _b24_preflight_done=1
+  local missing=""
+  for tool in awk jq curl; do
+    command -v "$tool" >/dev/null 2>&1 || missing="${missing} ${tool}"
+  done
+  if [[ -n "$missing" ]]; then
+    echo "[bitrix-lib] missing required tools:${missing}. Bitrix sync disabled. Install via brew/apt/choco." >&2
+    return 1
+  fi
+  return 0
+}
+
+# Read field value from CLAUDE.md (key = TASK_ID|CREATOR_ID|RESPONSIBLE_ID|PORTAL).
+# Format: "KEY: value [# optional comment]" — prints first whitespace-delimited token after "KEY:".
+# Uses awk (POSIX) so it works on macOS BSD where grep -P is unavailable.
+_b24_md_field() {
+  local file="$1"
+  local key="$2"
+  awk -v k="^${key}:" '$0 ~ k { print $2; exit }' "$file" 2>/dev/null
+}
+
+# Walk up from given dir, return first TASK_ID found in CLAUDE.md
+find_task_id() {
+  local dir="${1:-$(pwd)}"
+  while [[ "$dir" != "/" ]]; do
+    local md="$dir/CLAUDE.md"
+    if [[ -f "$md" ]]; then
+      local id
+      id=$(_b24_md_field "$md" "TASK_ID")
+      if [[ -n "$id" ]]; then
+        echo "$id"
+        return 0
+      fi
+    fi
+    dir=$(dirname "$dir")
+  done
+  return 1
+}
+
+# Walk up from given dir, find first CLAUDE.md with TASK_ID, parse all task meta.
+# Output: JSON {task_id, creator_id, responsible_id, portal} — empty string for missing fields.
+# Returns 1 if no TASK_ID found.
+find_task_meta() {
+  local dir="${1:-$(pwd)}"
+  while [[ "$dir" != "/" ]]; do
+    local md="$dir/CLAUDE.md"
+    if [[ -f "$md" ]]; then
+      local task_id
+      task_id=$(_b24_md_field "$md" "TASK_ID")
+      if [[ -n "$task_id" ]]; then
+        local creator_id responsible_id portal
+        creator_id=$(_b24_md_field "$md" "CREATOR_ID")
+        responsible_id=$(_b24_md_field "$md" "RESPONSIBLE_ID")
+        portal=$(_b24_md_field "$md" "PORTAL")
+        jq -n \
+          --arg tid "$task_id" \
+          --arg cid "$creator_id" \
+          --arg rid "$responsible_id" \
+          --arg portal "$portal" \
+          '{task_id: $tid, creator_id: $cid, responsible_id: $rid, portal: $portal}'
+        return 0
+      fi
+    fi
+    dir=$(dirname "$dir")
+  done
+  return 1
+}
+
+# POST JSON to Bitrix REST webhook; prints response JSON to stdout, silent on transport error.
+# Auto-rewrites URL to /rest/api/ when method is v3 (tasks.task.chat.*).
+b24_call() {
+  local method="$1"
+  local body="${2-}"
+  [[ -z "$body" ]] && body='{}'
+  [[ -z "${BITRIX_WEBHOOK_URL:-}" ]] && return 1
+  local url="${BITRIX_WEBHOOK_URL%/}"
+  case "$method" in
+    tasks.task.chat.*)
+      [[ "$url" != *"/rest/api/"* ]] && url=$(echo "$url" | sed 's|/rest/|/rest/api/|')
+      ;;
+  esac
+  curl -sS -m 10 -X POST "${url}/${method}" \
+    -H "Content-Type: application/json" \
+    -d "$body" 2>/dev/null
+}
+
+# Execute batch of up to 50 cmds; supports $result[cmd] chaining
+# Usage: b24_batch <json_cmd_object> [halt=1]
+b24_batch() {
+  local cmds="$1"
+  local halt="${2:-1}"
+  b24_call "batch" "$(jq -n --argjson cmd "$cmds" --argjson h "$halt" '{halt:$h,cmd:$cmd}')"
+}
+
+# Post message to Bitrix task chat (tasks.task.chat.message.send)
+b24_comment() {
+  local task_id="$1"
+  local message="$2"
+  b24_call "tasks.task.chat.message.send" \
+    "$(jq -n --argjson id "$task_id" --arg txt "$message" \
+        '{fields:{taskId:$id,text:$txt}}')"
+}
+
+# Start native timer on task. KEPT for backward compat — NOT used by current hooks.
+# tasks.task.startTimer / pauseTimer creates one system message per skill = noisy.
+# Hooks now use retroactive b24_log_elapsed_time at Stop instead.
+b24_timer_start() {
+  local task_id="$1"
+  b24_call "tasks.task.startTimer" \
+    "$(jq -n --argjson id "$task_id" '{taskId:$id}')" >/dev/null || true
+}
+
+b24_timer_stop() {
+  local task_id="$1"
+  b24_call "tasks.task.pauseTimer" \
+    "$(jq -n --argjson id "$task_id" '{taskId:$id}')" >/dev/null || true
+}
+
+# Add retroactive elapsed time entry to task (legacy task.elapseditem.add — v3 broken on portal).
+# Updates timeSpentInLogs cumulatively. Bitrix system message format:
+# "<user> activated time tracking. Duration: N seconds."
+# b24_log_elapsed_time <task_id> <seconds> [<comment>]
+b24_log_elapsed_time() {
+  local task_id="$1"
+  local seconds="${2:-0}"
+  local comment="${3:-AI session}"
+  [[ "$seconds" -le 0 ]] && return 0
+  b24_call "task.elapseditem.add" \
+    "$(jq -n \
+        --argjson tid "$task_id" \
+        --argjson sec "$seconds" \
+        --arg txt "$comment" \
+        '{TASKID:$tid,ARFIELDS:{SECONDS:$sec,COMMENT_TEXT:$txt}}')" >/dev/null || true
+}
+
+# Format duration in seconds → "Xs" (<60s) or "Xm Ys" / "Xm" (≥60s, no rounding inflation).
+# Examples: 30 → "30s"; 90 → "1m 30s"; 312 → "5m 12s"; 600 → "10m"
+_format_duration() {
+  local sec="${1:-0}"
+  [[ ! "$sec" =~ ^[0-9]+$ ]] && sec=0
+  if [[ "$sec" -lt 60 ]]; then
+    printf '%ds' "$sec"
+  else
+    local m=$((sec / 60))
+    local s=$((sec % 60))
+    if [[ "$s" -eq 0 ]]; then
+      printf '%dm' "$m"
+    else
+      printf '%dm %ds' "$m" "$s"
+    fi
+  fi
+}
+
+# Sync plan phases as named checklists via batch API (max 50 cmds total)
+# Usage: b24_sync_checklist <task_id> <phases_json>
+# phases_json: '[{"name":"Phase 1","items":["item a","item b"]},...]'
+b24_sync_checklist() {
+  local task_id="$1"
+  local phases_json="$2"
+  local cmd='{}' i=0
+  local phase_count
+  phase_count=$(echo "$phases_json" | jq 'length')
+
+  for ((i=0; i<phase_count; i++)); do
+    local cl_key="cl_${i}"
+    local phase_name encoded_name
+    phase_name=$(echo "$phases_json" | jq -r ".[$i].name")
+    encoded_name=$(printf '%s' "$phase_name" | jq -Rr '@uri')
+
+    # PARENT_ID=0 → create new named checklist
+    cmd=$(echo "$cmd" | jq \
+      --arg k "$cl_key" \
+      --arg v "task.checklistitem.add?TASKID=${task_id}&FIELDS[TITLE]=${encoded_name}&FIELDS[PARENT_ID]=0" \
+      '. + {($k): $v}')
+
+    local item_count j
+    item_count=$(echo "$phases_json" | jq ".[$i].items | length")
+
+    for ((j=0; j<item_count; j++)); do
+      local item_key encoded_item
+      # \$result → literal $result in the batch cmd string (not bash expansion)
+      encoded_item=$(echo "$phases_json" | jq -r ".[$i].items[$j]" | jq -Rr '@uri')
+      item_key="item_${i}_${j}"
+
+      cmd=$(echo "$cmd" | jq \
+        --arg k "$item_key" \
+        --arg v "task.checklistitem.add?TASKID=${task_id}&FIELDS[TITLE]=${encoded_item}&FIELDS[PARENT_ID]=\$result[${cl_key}]" \
+        '. + {($k): $v}')
+    done
+  done
+
+  local total
+  total=$(echo "$cmd" | jq 'length')
+  if [[ "$total" -gt 50 ]]; then
+    echo "Warning: $total cmds exceeds batch limit of 50. Sync skipped." >&2
+    return 1
+  fi
+
+  b24_batch "$cmd"
+}
+
+# Map skill name to emoji
+# Return 0 (true) if text has human-readable content worth posting to Bitrix chat.
+# Skips: empty, pure JSON object/array, strings shorter than 20 non-whitespace chars.
+_has_useful_content() {
+  local text="${1:-}"
+  [[ -z "$text" ]] && return 1
+  # Pure JSON object or array → skip (e.g. {"success":true} or [])
+  local first="${text:0:1}"
+  if [[ "$first" == "{" || "$first" == "[" ]]; then
+    echo "$text" | jq -e 'type == "object" or type == "array"' >/dev/null 2>&1 && return 1
+  fi
+  # Too short after stripping whitespace → skip
+  local trimmed="${text//[[:space:]]/}"
+  [[ ${#trimmed} -lt 20 ]] && return 1
+  return 0
+}
+
+skill_emoji() {
+  case "$1" in
+    brainstorm)       echo "🧠" ;;
+    research)         echo "🔍" ;;
+    cook)             echo "👨‍🍳" ;;
+    debug)            echo "🐛" ;;
+    fix)              echo "🔧" ;;
+    review)           echo "👀" ;;
+    plan|planner)     echo "📋" ;;
+    test|tester)      echo "🧪" ;;
+    security-review)  echo "🔒" ;;
+    *)                echo "⚡" ;;
+  esac
+}
+
+# ── Phase 2: Time tracking lifecycle ────────────────────────────────────────
+
+# Atomic skill counter (flock-based) so overlapping PreToolUse calls are safe.
+_skill_counter_path() { echo "$SESSION_DIR/skill-counter-${1}"; }
+
+_skill_counter_incr() {
+  local f; f=$(_skill_counter_path "$1")
+  (
+    flock -x 200
+    local cur=0
+    [[ -f "$f" ]] && cur=$(cat "$f")
+    cur=$((cur + 1))
+    echo "$cur" > "$f"
+    echo "$cur"
+  ) 200>"${f}.lock"
+}
+
+_skill_counter_decr() {
+  local f; f=$(_skill_counter_path "$1")
+  (
+    flock -x 200
+    local cur=0
+    [[ -f "$f" ]] && cur=$(cat "$f")
+    cur=$((cur - 1)); [[ "$cur" -lt 0 ]] && cur=0
+    echo "$cur" > "$f"
+    echo "$cur"
+  ) 200>"${f}.lock"
+}
+
+# Return current task status (string: "1"=new "2"=waiting "3"=in_progress "5"=closed)
+b24_task_status() {
+  local task_id="$1"
+  b24_call "tasks.task.get" \
+    "$(jq -n --argjson id "$task_id" '{taskId:$id,select:["STATUS"]}')" \
+    | jq -r '.result.task.status // empty'
+}
+
+# Ensure allowTimeTracking='Y'. Silently enable — no chat audit (system noise).
+b24_ensure_timetracking() {
+  local task_id="$1"
+  local get_resp allow_flag
+  get_resp=$(b24_call "tasks.task.get" \
+    "$(jq -n --argjson id "$task_id" '{taskId:$id,select:["ALLOW_TIME_TRACKING"]}')")
+  allow_flag=$(echo "$get_resp" | jq -r '.result.task.allowTimeTracking // "N"')
+  [[ "$allow_flag" == "Y" ]] && return 0
+
+  b24_call "tasks.task.update" \
+    "$(jq -n --argjson id "$task_id" '{taskId:$id,fields:{ALLOW_TIME_TRACKING:"Y"}}')" >/dev/null || true
+}
+
+# ── Phase 1: Token tracking ──────────────────────────────────────────────────
+
+# One-time: ensure UF_AI_TOKENS_TOTAL user field exists on TASKS_TASK entity.
+b24_ensure_uf() {
+  local result err
+  result=$(b24_call "task.item.userfield.add" \
+    "$(jq -n '{PARAMS:{USER_TYPE_ID:"double",FIELD_NAME:"UF_AI_TOKENS_TOTAL",
+      XML_ID:"UF_AI_TOKENS_TOTAL",LABEL:"AI Tokens (cumulative)",
+      SORT:500,MULTIPLE:"N",MANDATORY:"N",SETTINGS:{DEFAULT_VALUE:0,PRECISION:0}}}')")
+  err=$(echo "$result" | jq -r '.error // empty')
+  # "ERROR_CORE" = already exists → treat as success
+  [[ -n "$err" && "$err" != "ERROR_CORE" ]] && \
+    echo "[bitrix-lib] b24_ensure_uf warning: $err" >&2
+  return 0
+}
+
+# Read current UF_AI_TOKENS_TOTAL value from task (returns integer).
+b24_task_get_uf_tokens() {
+  local task_id="$1"
+  local val
+  val=$(b24_call "tasks.task.get" \
+    "$(jq -n --argjson id "$task_id" '{taskId:$id,select:["UF_AI_TOKENS_TOTAL"]}')" \
+    | jq -r '.result.task.ufAiTokensTotal // "0"')
+  # Coerce string → integer (Bitrix v3 returns camelCase string values)
+  echo "${val%%.*}" | tr -cd '0-9' || echo "0"
+}
+
+# Write UF_AI_TOKENS_TOTAL value to task.
+b24_task_set_uf_tokens() {
+  local task_id="$1"
+  local total="$2"
+  b24_call "tasks.task.update" \
+    "$(jq -n --argjson id "$task_id" --argjson val "$total" \
+        '{taskId:$id,fields:{UF_AI_TOKENS_TOTAL:$val}}')" >/dev/null || true
+}
+
+# Parse session tokens from transcript JSONL; returns JSON {input,output,cacheRead,cacheCreation}.
+_compute_session_tokens() {
+  local transcript="$1"
+  [[ ! -f "$transcript" ]] && echo '{"input":0,"output":0,"cacheRead":0,"cacheCreation":0}' && return
+  jq -s '
+    [ .[] | select(.type == "assistant") | .message.usage // empty |
+      { i: (.input_tokens // 0),
+        o: (.output_tokens // 0),
+        cr: (.cache_read_input_tokens // 0),
+        cc: (.cache_creation_input_tokens // 0) }
+    ] |
+    reduce .[] as $u ({input:0,output:0,cacheRead:0,cacheCreation:0};
+      .input += $u.i | .output += $u.o | .cacheRead += $u.cr | .cacheCreation += $u.cc
+    )
+  ' "$transcript" 2>/dev/null || echo '{"input":0,"output":0,"cacheRead":0,"cacheCreation":0}'
+}
+
+# Read transcript, accumulate UF, return formatted summary line.
+# b24_finalize_session_tokens <task_id> <transcript_path>
+b24_finalize_session_tokens() {
+  local task_id="$1"
+  local transcript="$2"
+  local session input output cache_read new_total current
+
+  session=$(_compute_session_tokens "$transcript")
+  input=$(echo "$session" | jq -r '.input // 0')
+  output=$(echo "$session" | jq -r '.output // 0')
+  cache_read=$(echo "$session" | jq -r '.cacheRead // 0')
+
+  local session_total=$((input + output))
+  if [[ "$session_total" -le 0 ]]; then
+    echo "[bts] token probe found 0 tokens (transcript=${transcript}) — UF skipped" >&2
+    return 0
+  fi
+
+  current=$(b24_task_get_uf_tokens "$task_id")
+  new_total=$((${current:-0} + session_total))
+  b24_task_set_uf_tokens "$task_id" "$new_total"
+
+  local inp_k out_k cr_k
+  inp_k=$(awk "BEGIN{printf \"%.1f\", $input/1000}")
+  out_k=$(awk "BEGIN{printf \"%.1f\", $output/1000}")
+  cr_k=$(awk "BEGIN{printf \"%.1f\", $cache_read/1000}")
+  printf '🪙 %sk in / %sk out / %sk cached | task total: %s tokens' \
+    "$inp_k" "$out_k" "$cr_k" "$new_total"
+}
+
+# ── Phase 3: File attach (drive) ─────────────────────────────────────────────
+
+# Resolve group drive root folder for a task; caches in session tmp.
+# Returns ROOT_OBJECT_ID. Falls back to user drive + warns.
+# b24_disk_get_root_folder <task_id> <session_id>
+b24_disk_get_root_folder() {
+  local task_id="$1"
+  local session_id="${2:-default}"
+  local cache_file="$SESSION_DIR/disk-root-${session_id}"
+
+  if [[ -f "$cache_file" ]]; then
+    cat "$cache_file"
+    return 0
+  fi
+
+  # Get groupId from task
+  local group_id
+  group_id=$(b24_call "tasks.task.get" \
+    "$(jq -n --argjson id "$task_id" '{taskId:$id,select:["GROUP_ID"]}')" \
+    | jq -r '.result.task.groupId // empty')
+
+  local resp folder_id
+  if [[ -n "$group_id" && "$group_id" != "0" ]]; then
+    resp=$(b24_call "disk.storage.getlist" \
+      "$(jq -n --argjson eid "$group_id" '{filter:{ENTITY_TYPE:"group",ENTITY_ID:$eid}}')")
+    folder_id=$(echo "$resp" | jq -r '.result[0].ROOT_OBJECT_ID // empty')
+  fi
+
+  if [[ -z "$folder_id" ]]; then
+    # Fallback: user personal drive (warn to stderr, not chat)
+    resp=$(b24_call "disk.storage.getlist" '{"filter":{"ENTITY_TYPE":"user"}}')
+    folder_id=$(echo "$resp" | jq -r '.result[0].ROOT_OBJECT_ID // empty')
+    echo "[bts] no group drive — using user personal drive" >&2
+  fi
+
+  [[ -z "$folder_id" ]] && return 1
+  echo "$folder_id" > "$cache_file"
+  echo "$folder_id"
+}
+
+# Ensure named subfolder exists under parent; returns folder ID.
+# b24_disk_ensure_folder <parent_folder_id> <name>
+b24_disk_ensure_folder() {
+  local parent_id="$1"
+  local name="$2"
+
+  local children_resp existing_id
+  children_resp=$(b24_call "disk.folder.getchildren" \
+    "$(jq -n --argjson pid "$parent_id" '{id:$pid,filter:{TYPE:"folder"}}')")
+  existing_id=$(echo "$children_resp" | jq -r \
+    --arg n "$name" '.result[] | select(.NAME == $n) | .ID' | head -1)
+
+  if [[ -n "$existing_id" ]]; then
+    echo "$existing_id"
+    return 0
+  fi
+
+  local new_resp
+  new_resp=$(b24_call "disk.folder.addsubfolder" \
+    "$(jq -n --argjson pid "$parent_id" --arg n "$name" '{id:$pid,data:{NAME:$n}}')")
+  echo "$new_resp" | jq -r '.result.ID // empty'
+}
+
+# Upload file to drive folder; returns drive object ID.
+# b24_disk_upload <folder_id> <file_path>
+b24_disk_upload() {
+  local folder_id="$1"
+  local file_path="$2"
+  local file_name; file_name=$(basename "$file_path")
+  local b64; b64=$(base64 -i "$file_path" 2>/dev/null || base64 "$file_path")
+  b64=$(echo "$b64" | tr -d '\n')
+
+  b24_call "disk.folder.uploadfile" \
+    "$(jq -n \
+        --argjson fid "$folder_id" \
+        --arg name "$file_name" \
+        --arg content "$b64" \
+        '{id:$fid,data:{NAME:$name},fileContent:[$name,$content],generateUniqueName:true}')" \
+    | jq -r '.result.ID // empty'
+}
+
+# Attach drive file to task (legacy method — v3 tasks.task.file.attach broken on portal).
+# b24_task_attach_file <task_id> <drive_file_id>
+# Echoes attachmentId on success, empty on failure.
+b24_task_attach_file() {
+  local task_id="$1"
+  local file_id="$2"
+  local resp
+  resp=$(b24_call "tasks.task.files.attach" \
+    "$(jq -n --argjson tid "$task_id" --argjson fid "$file_id" \
+        '{taskId:$tid,fileId:$fid}')")
+  echo "$resp" | jq -r '.result.attachmentId // empty'
+}
+
+# High-level: resolve group drive root, build folder path AI Sessions/<repo>/<rel_path>/,
+# upload and attach file. Returns drive file ID or empty on failure.
+# b24_attach_artifact <task_id> <file_path> <session_id> [<rel_dir>]
+b24_attach_artifact() {
+  local task_id="$1"
+  local file_path="$2"
+  local session_id="${3:-default}"
+  local rel_dir="${4:-}"
+
+  [[ ! -f "$file_path" ]] && return 1
+
+  local root_folder_id
+  root_folder_id=$(b24_disk_get_root_folder "$task_id" "$session_id") || return 1
+
+  # Ensure AI Sessions/ folder
+  local ai_folder_id
+  ai_folder_id=$(b24_disk_ensure_folder "$root_folder_id" "AI Sessions") || return 1
+
+  # Repo name from git — use git-common-dir to resolve correctly inside worktrees.
+  # Normal repo: --git-common-dir = ".git" (relative) → use --show-toplevel
+  # Worktree:    --git-common-dir = "/abs/path/to/main/.git" → dirname gives real root
+  local repo_name _git_common
+  _git_common=$(git rev-parse --git-common-dir 2>/dev/null)
+  if [[ "${_git_common:0:1}" == "/" ]]; then
+    repo_name=$(basename "$(dirname "$_git_common")" 2>/dev/null || echo "repo")
+  else
+    repo_name=$(git rev-parse --show-toplevel 2>/dev/null | xargs basename 2>/dev/null || echo "repo")
+  fi
+  local repo_folder_id
+  repo_folder_id=$(b24_disk_ensure_folder "$ai_folder_id" "$repo_name") || return 1
+
+  # Optional sub-directory (e.g. plan dir)
+  local target_folder_id="$repo_folder_id"
+  if [[ -n "$rel_dir" ]]; then
+    # Walk each segment of rel_dir
+    local segment
+    IFS='/' read -ra segs <<< "$rel_dir"
+    for segment in "${segs[@]}"; do
+      [[ -z "$segment" ]] && continue
+      target_folder_id=$(b24_disk_ensure_folder "$target_folder_id" "$segment") || return 1
+    done
+  fi
+
+  local drive_file_id
+  drive_file_id=$(b24_disk_upload "$target_folder_id" "$file_path") || return 1
+  [[ -z "$drive_file_id" ]] && return 1
+
+  local attach_id
+  attach_id=$(b24_task_attach_file "$task_id" "$drive_file_id") || true
+  [[ -z "$attach_id" ]] && echo "[bts] warn: task attach failed for drive_id=$drive_file_id" >&2
+  echo "$drive_file_id"
+}

package/src/features/task-sync/assets/scripts/lib/time-helpers.sh

@@ -0,0 +1,57 @@
+#!/bin/bash
+# Duration formatting helpers — standalone, no external dependencies.
+# Ported from _format_duration in bitrix-lib.sh.
+#
+# Can be sourced directly or used standalone.
+#
+# Usage:
+#   source "$(dirname "$0")/time-helpers.sh"
+#   _format_duration 312   # → "5m 12s"
+#   _parse_duration "5m 12s"  # → 312
+
+# Format duration in seconds → "Xs" (<60s) or "Xm Ys" / "Xm" (>=60s).
+# No rounding inflation — exact integer arithmetic.
+#
+# Examples:
+#   30  → "30s"
+#   90  → "1m 30s"
+#   312 → "5m 12s"
+#   600 → "10m"
+_format_duration() {
+  local sec="${1:-0}"
+  [[ ! "$sec" =~ ^[0-9]+$ ]] && sec=0
+  if [[ "$sec" -lt 60 ]]; then
+    printf '%ds' "$sec"
+  else
+    local m=$(( sec / 60 ))
+    local s=$(( sec % 60 ))
+    if [[ "$s" -eq 0 ]]; then
+      printf '%dm' "$m"
+    else
+      printf '%dm %ds' "$m" "$s"
+    fi
+  fi
+}
+
+# Parse a human-readable duration string back to seconds.
+# Accepts: "30s", "5m", "5m 12s"
+# Returns 0 for unrecognised input.
+_parse_duration() {
+  local str="${1:-}"
+  # "Xm Ys"
+  if [[ "$str" =~ ^([0-9]+)m[[:space:]]+([0-9]+)s$ ]]; then
+    echo $(( BASH_REMATCH[1] * 60 + BASH_REMATCH[2] ))
+    return 0
+  fi
+  # "Xm"
+  if [[ "$str" =~ ^([0-9]+)m$ ]]; then
+    echo $(( BASH_REMATCH[1] * 60 ))
+    return 0
+  fi
+  # "Xs"
+  if [[ "$str" =~ ^([0-9]+)s$ ]]; then
+    echo "${BASH_REMATCH[1]}"
+    return 0
+  fi
+  echo 0
+}

package/src/features/task-sync/assets/workflows/bitrix-sync.yml

@@ -0,0 +1,85 @@
+name: Bitrix Task Sync
+
+on:
+  pull_request:
+    types: [closed]
+    branches: [main, develop]
+
+concurrency:
+  group: bitrix-sync-${{ github.event.pull_request.number }}
+  cancel-in-progress: false
+
+jobs:
+  preflight:
+    if: github.event.pull_request.merged == true
+    runs-on: ubuntu-latest
+    timeout-minutes: 1
+    steps:
+      - name: Verify BITRIX_WEBHOOK_URL secret
+        env:
+          WEBHOOK: ${{ secrets.BITRIX_WEBHOOK_URL }}
+        run: |
+          if [[ -z "$WEBHOOK" ]]; then
+            echo "::error::BITRIX_WEBHOOK_URL secret not set. Add it via Settings → Secrets and variables → Actions."
+            exit 1
+          fi
+          if ! [[ "$WEBHOOK" =~ ^https://[^/]+\.bitrix24\.[a-z.]+/rest/[0-9]+/[a-z0-9]+/?$ ]]; then
+            echo "::error::BITRIX_WEBHOOK_URL format invalid (expected https://<portal>.bitrix24.<tld>/rest/<user_id>/<token>/)"
+            exit 1
+          fi
+          echo "✓ Webhook URL format OK"
+
+  notify-bitrix:
+    needs: preflight
+    if: github.event.pull_request.merged == true
+    runs-on: ubuntu-latest
+    timeout-minutes: 2
+    steps:
+      - name: Extract task ID
+        id: extract
+        env:
+          BRANCH: ${{ github.event.pull_request.head.ref }}
+          PR_BODY: ${{ github.event.pull_request.body }}
+        run: |
+          # Priority 1: [B24:ID] in commit message or PR body
+          TASK_ID=$(echo "$PR_BODY" | grep -oP '(?<=\[B24:)\d+(?=\])' | head -1)
+
+          # Priority 2: task ID from branch name (feature/{id}-slug)
+          if [[ -z "$TASK_ID" && "$BRANCH" =~ ^(feature|fix)/([0-9]+)- ]]; then
+            TASK_ID="${BASH_REMATCH[2]}"
+          fi
+
+          if [[ -z "$TASK_ID" ]]; then
+            echo "No task ID found — skipping"
+            echo "skip=true" >> $GITHUB_OUTPUT
+          else
+            echo "task_id=$TASK_ID" >> $GITHUB_OUTPUT
+            echo "branch=$BRANCH" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Post to Bitrix task chat
+        if: steps.extract.outputs.skip != 'true'
+        env:
+          BITRIX_WEBHOOK_URL: ${{ secrets.BITRIX_WEBHOOK_URL }}
+          PR_TITLE: ${{ github.event.pull_request.title }}
+          PR_AUTHOR: ${{ github.event.pull_request.user.login }}
+          PR_URL: ${{ github.event.pull_request.html_url }}
+        run: |
+          TASK_ID="${{ steps.extract.outputs.task_id }}"
+          BRANCH="${{ steps.extract.outputs.branch }}"
+          TARGET="${{ github.event.pull_request.base.ref }}"
+          PR_NUM="${{ github.event.pull_request.number }}"
+
+          ENV_LABEL=$([[ "$TARGET" == "main" ]] && echo "[PROD]" || echo "[DEV]")
+
+          MSG=$(printf "[B]%s ✓ Merged PR #%s:[/B] %s\n[I]by %s | %s → %s[/I]\n[URL=%s]View on GitHub[/URL]" \
+            "$ENV_LABEL" "$PR_NUM" "$PR_TITLE" "$PR_AUTHOR" "$BRANCH" "$TARGET" "$PR_URL")
+
+          BASE_URL="${BITRIX_WEBHOOK_URL%/}"
+          [[ "$BASE_URL" != *"/rest/api/"* ]] && BASE_URL=$(echo "$BASE_URL" | sed 's|/rest/|/rest/api/|')
+
+          curl -sS -X POST "${BASE_URL}/tasks.task.chat.message.send" \
+            -H "Content-Type: application/json" \
+            -d "$(jq -n --arg id "$TASK_ID" --arg msg "$MSG" \
+                '{fields:{taskId:($id|tonumber),text:$msg}}')" \
+            --max-time 15 || echo "Warning: Bitrix notification failed (non-blocking)"