work-ally 0.2.0-alpha.1

package/internal/modules/runtime/start.sh

@@ -0,0 +1,283 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck disable=SC1091
+. "$SCRIPT_DIR/../../lib/common.sh"
+work_ally_init_context
+work_ally_install_bridge_dependencies
+
+PREVIOUS_ASSISTANT_NAME="${WORK_ALLY_ASSISTANT_NAME:-}"
+ASSISTANT_NAME=$(work_ally_resolve_assistant_name_from_args "$@")
+work_ally_sync_workspace_root_from_assistant "$ASSISTANT_NAME"
+work_ally_hydrate_assistant_context "$ASSISTANT_NAME"
+work_ally_ensure_state_dirs
+work_ally_ensure_env_defaults
+work_ally_load_env
+work_ally_load_assistant_state || true
+
+CHANNEL_IMPL="${WORK_ALLY_CHANNEL_IMPL:-feishu}"
+RUNTIME_MODE="${WORK_ALLY_RUNTIME_MODE:-codex}"
+FOREGROUND="${WORK_ALLY_FOREGROUND:-0}"
+ASSISTANT_GIT_REMOTE="${WORK_ALLY_ASSISTANT_GIT_REMOTE:-}"
+
+if [ "$FOREGROUND" != "1" ] && work_ally_is_managed_ai_shell; then
+  work_ally_die "Current managed AI shell is not a reliable host for long-running background services. Please run $(work_ally_cmd_name) start in your own terminal."
+fi
+
+work_ally_require_assistant_profile_ready "$ASSISTANT_NAME"
+ASSISTANT_HOME=$(work_ally_assistant_registered_home "$ASSISTANT_NAME")
+ASSISTANT_CODEX_HOME=$(work_ally_assistant_registered_codex_home "$ASSISTANT_NAME")
+
+if [ "$RUNTIME_MODE" = "codex" ]; then
+  work_ally_assert_codex_env_keys_available
+fi
+
+if [ "$CHANNEL_IMPL" = "feishu" ]; then
+  [ -n "${FEISHU_APP_ID:-}" ] || work_ally_die "FEISHU_APP_ID is required"
+  [ -n "${FEISHU_APP_SECRET:-}" ] || work_ally_die "FEISHU_APP_SECRET is required"
+fi
+
+notify_start_if_possible() {
+  local notice_output=""
+  local notice_status=0
+
+  if [ "${WORK_ALLY_CHANNEL_IMPL:-feishu}" != "feishu" ]; then
+    return 0
+  fi
+  if [ -z "${FEISHU_APP_ID:-}" ] || [ -z "${FEISHU_APP_SECRET:-}" ]; then
+    return 0
+  fi
+
+  notice_output=$(WORK_ALLY_SYSTEM_NOTICE_STRICT=1 node "$WORK_ALLY_IMPLEMENTATION_DIR/bridge/src/system-notify.ts" start 2>&1) || notice_status=$?
+  if [ "$notice_status" -eq 2 ]; then
+    if [ "${FOREGROUND:-0}" = "1" ]; then
+      work_ally_stop_bridge_processes
+      stop_autosave_if_needed
+      work_ally_release_channel_lock "$$"
+      work_ally_release_assistant_lock "$ASSISTANT_NAME" "$$"
+    else
+      stop_supervisor_if_needed
+      work_ally_stop_bridge_processes
+      stop_autosave_if_needed
+      work_ally_release_channel_lock
+      work_ally_release_assistant_lock "$ASSISTANT_NAME"
+    fi
+    work_ally_die "${notice_output:-Feishu 机器人当前还不能发消息。请先完成权限开通或审核发布，再重新执行 ally start。}"
+  fi
+  if [ "$notice_status" -ne 0 ]; then
+    work_ally_warn "startup notice probe failed: ${notice_output:-unknown error}"
+  fi
+}
+
+BRIDGE_PID_FILE=$(work_ally_pid_file bridge)
+AUTOSAVE_PID_FILE=$(work_ally_pid_file assistant-autosave)
+SUPERVISOR_PID_FILE=$(work_ally_pid_file supervisor)
+BRIDGE_LOG=$(work_ally_log_file_for bridge)
+AUTOSAVE_LOG=$(work_ally_log_file_for assistant-autosave)
+SUPERVISOR_LOG=$(work_ally_log_file_for supervisor)
+work_ally_prune_logs
+DID_START_NEW=0
+
+wait_for_background_ready() {
+  local attempt=0
+  while [ "$attempt" -lt 25 ]; do
+    local bridge_pid autosave_pid supervisor_pid
+    bridge_pid=$(work_ally_primary_bridge_pid || true)
+    if [ -n "$bridge_pid" ] && work_ally_is_pid_alive "$bridge_pid"; then
+      echo "$bridge_pid" > "$BRIDGE_PID_FILE"
+      autosave_pid=$(work_ally_read_pid "$AUTOSAVE_PID_FILE" || true)
+      if [ -n "$autosave_pid" ] && work_ally_is_pid_alive "$autosave_pid"; then
+        return 0
+      fi
+    fi
+    if [ -f "$SUPERVISOR_PID_FILE" ]; then
+      supervisor_pid=$(work_ally_read_pid "$SUPERVISOR_PID_FILE" || true)
+      if [ -n "$supervisor_pid" ] && ! work_ally_is_pid_alive "$supervisor_pid"; then
+        return 1
+      fi
+    fi
+    attempt=$((attempt + 1))
+    sleep 1
+  done
+  return 1
+}
+
+stop_autosave_if_needed() {
+  local pid
+  pid=$(work_ally_read_pid "$AUTOSAVE_PID_FILE" || true)
+  if [ -n "$pid" ] && work_ally_is_pid_alive "$pid"; then
+    work_ally_terminate_pid "$pid"
+  fi
+  rm -f "$AUTOSAVE_PID_FILE"
+  work_ally_write_health assistant-autosave stopped '{}'
+}
+
+stop_supervisor_if_needed() {
+  local pid
+  pid=$(work_ally_read_pid "$SUPERVISOR_PID_FILE" || true)
+  if [ -n "$pid" ] && work_ally_is_pid_alive "$pid"; then
+    work_ally_terminate_pid "$pid"
+  fi
+  rm -f "$SUPERVISOR_PID_FILE"
+  work_ally_write_health supervisor stopped '{}'
+}
+
+reset_running_services_for_assistant_switch() {
+  if [ -n "$PREVIOUS_ASSISTANT_NAME" ] && [ "$PREVIOUS_ASSISTANT_NAME" != "$ASSISTANT_NAME" ]; then
+    work_ally_note "Switching assistant from $PREVIOUS_ASSISTANT_NAME to $ASSISTANT_NAME"
+    stop_supervisor_if_needed
+    work_ally_stop_bridge_processes
+    stop_autosave_if_needed
+  fi
+}
+
+start_autosave_background() {
+  local existing_pid autosave_pid
+
+  work_ally_assistant_git_setup "$ASSISTANT_HOME" "$ASSISTANT_GIT_REMOTE" || true
+  work_ally_assistant_git_checkpoint "$ASSISTANT_HOME" "start assistant $ASSISTANT_NAME" || true
+
+  existing_pid=$(work_ally_read_pid "$AUTOSAVE_PID_FILE" || true)
+  if [ -n "$existing_pid" ] && work_ally_is_pid_alive "$existing_pid"; then
+    work_ally_write_health assistant-autosave running "{\"assistant\": \"$ASSISTANT_NAME\", \"pid\": ${existing_pid}, \"workspaceRoot\": \"$WORK_ALLY_WORKSPACE_ROOT\"}"
+    return 0
+  fi
+
+  nohup env \
+    WORK_ALLY_ASSISTANT_MODE="assistant" \
+    WORK_ALLY_ASSISTANT_NAME="$ASSISTANT_NAME" \
+    WORK_ALLY_ASSISTANT_HOME="$ASSISTANT_HOME" \
+    WORK_ALLY_ASSISTANT_CODEX_HOME="$ASSISTANT_CODEX_HOME" \
+    WORK_ALLY_ASSISTANT_GIT_REMOTE="$ASSISTANT_GIT_REMOTE" \
+    WORK_ALLY_WORKSPACE_ROOT="$WORK_ALLY_WORKSPACE_ROOT" \
+    WORK_ALLY_STATE_DIR="$WORK_ALLY_STATE_DIR" \
+    WORK_ALLY_INSTALL_ROOT="$WORK_ALLY_INSTALL_ROOT" \
+    WORK_ALLY_IMPLEMENTATION_DIR="$WORK_ALLY_IMPLEMENTATION_DIR" \
+    "$WORK_ALLY_IMPLEMENTATION_DIR/internal/modules/runtime/assistant-autosave.sh" >"$AUTOSAVE_LOG" 2>&1 &
+  echo $! > "$AUTOSAVE_PID_FILE"
+  sleep 1
+  autosave_pid=$(work_ally_read_pid "$AUTOSAVE_PID_FILE" || true)
+  if [ -n "$autosave_pid" ] && work_ally_is_pid_alive "$autosave_pid"; then
+    work_ally_write_health assistant-autosave running "{\"assistant\": \"$ASSISTANT_NAME\", \"pid\": ${autosave_pid}, \"workspaceRoot\": \"$WORK_ALLY_WORKSPACE_ROOT\"}"
+    return 0
+  fi
+  rm -f "$AUTOSAVE_PID_FILE"
+  work_ally_write_health assistant-autosave stopped '{}'
+}
+
+reset_running_services_for_assistant_switch
+work_ally_assert_assistant_available "$ASSISTANT_NAME"
+work_ally_write_assistant_state "$ASSISTANT_NAME" "$ASSISTANT_HOME" "$ASSISTANT_CODEX_HOME"
+
+start_supervisor_background() {
+  local supervisor_pid existing_supervisor_pid
+
+  existing_supervisor_pid=$(work_ally_read_pid "$SUPERVISOR_PID_FILE" || true)
+  if [ -n "$existing_supervisor_pid" ] && work_ally_is_pid_alive "$existing_supervisor_pid" && [ "${WORK_ALLY_ENV_UPDATED:-0}" != "1" ]; then
+    local existing_bridge_pid
+    existing_bridge_pid=$(work_ally_primary_bridge_pid || true)
+    if [ -n "$existing_bridge_pid" ]; then
+      echo "$existing_bridge_pid" > "$BRIDGE_PID_FILE"
+    fi
+    if wait_for_background_ready; then
+      return 0
+    fi
+    work_ally_warn "Existing supervisor is unhealthy; restarting"
+  elif [ "${WORK_ALLY_ENV_UPDATED:-0}" = "1" ]; then
+    work_ally_note "Runtime config changed; restarting background supervisor"
+  fi
+
+  stop_supervisor_if_needed
+  work_ally_stop_bridge_processes
+  stop_autosave_if_needed
+  work_ally_assert_channel_available
+
+  work_ally_note "Starting work-ally supervisor"
+  nohup env \
+    CODEX_HOME="$ASSISTANT_CODEX_HOME" \
+    WORK_ALLY_ASSISTANT_MODE="assistant" \
+    WORK_ALLY_ASSISTANT_NAME="$ASSISTANT_NAME" \
+    WORK_ALLY_ASSISTANT_HOME="$ASSISTANT_HOME" \
+    WORK_ALLY_ASSISTANT_CODEX_HOME="$ASSISTANT_CODEX_HOME" \
+    WORK_ALLY_ASSISTANT_GIT_REMOTE="$ASSISTANT_GIT_REMOTE" \
+    WORK_ALLY_WORKSPACE_ROOT="$WORK_ALLY_WORKSPACE_ROOT" \
+    WORK_ALLY_STATE_DIR="$WORK_ALLY_STATE_DIR" \
+    WORK_ALLY_INSTALL_ROOT="$WORK_ALLY_INSTALL_ROOT" \
+    WORK_ALLY_IMPLEMENTATION_DIR="$WORK_ALLY_IMPLEMENTATION_DIR" \
+    "$WORK_ALLY_IMPLEMENTATION_DIR/internal/modules/runtime/supervisor.sh" >"$SUPERVISOR_LOG" 2>&1 &
+  echo $! > "$SUPERVISOR_PID_FILE"
+  supervisor_pid=$(work_ally_read_pid "$SUPERVISOR_PID_FILE" || true)
+  if [ -z "$supervisor_pid" ] || ! work_ally_is_pid_alive "$supervisor_pid"; then
+    rm -f "$SUPERVISOR_PID_FILE"
+    work_ally_die "Failed to start supervisor"
+  fi
+
+  if ! wait_for_background_ready; then
+    stop_supervisor_if_needed
+    work_ally_die "Failed to start background services"
+  fi
+
+  DID_START_NEW=1
+}
+
+run_bridge_foreground() {
+  local bridge_pid=""
+
+  cleanup() {
+    if [ -n "$bridge_pid" ] && work_ally_is_pid_alive "$bridge_pid"; then
+      kill "$bridge_pid" >/dev/null 2>&1 || true
+      wait "$bridge_pid" 2>/dev/null || true
+    fi
+    work_ally_stop_bridge_processes
+    stop_autosave_if_needed
+    work_ally_release_channel_lock "$$"
+    work_ally_release_assistant_lock "$ASSISTANT_NAME" "$$"
+    work_ally_assistant_git_checkpoint "$ASSISTANT_HOME" "stop assistant $ASSISTANT_NAME" || true
+  }
+
+  trap cleanup EXIT INT TERM
+  work_ally_assert_channel_available
+  work_ally_claim_assistant_lock "$ASSISTANT_NAME" "$$"
+  work_ally_claim_channel_lock "$$"
+  work_ally_note "Starting work-ally bridge in foreground"
+  start_autosave_background
+  env \
+    CODEX_HOME="$ASSISTANT_CODEX_HOME" \
+    WORK_ALLY_ASSISTANT_MODE="assistant" \
+    WORK_ALLY_ASSISTANT_NAME="$ASSISTANT_NAME" \
+    WORK_ALLY_ASSISTANT_HOME="$ASSISTANT_HOME" \
+    WORK_ALLY_ASSISTANT_CODEX_HOME="$ASSISTANT_CODEX_HOME" \
+    WORK_ALLY_WORKSPACE_ROOT="$WORK_ALLY_WORKSPACE_ROOT" \
+    WORK_ALLY_STATE_DIR="$WORK_ALLY_STATE_DIR" \
+    WORK_ALLY_INSTALL_ROOT="$WORK_ALLY_INSTALL_ROOT" \
+    WORK_ALLY_IMPLEMENTATION_DIR="$WORK_ALLY_IMPLEMENTATION_DIR" \
+    node "$WORK_ALLY_IMPLEMENTATION_DIR/bridge/src/server.ts" >"$BRIDGE_LOG" 2>&1 &
+  bridge_pid=$!
+  echo "$bridge_pid" > "$BRIDGE_PID_FILE"
+  sleep 2
+  if ! work_ally_is_pid_alive "$bridge_pid"; then
+    work_ally_release_channel_lock "$$"
+    work_ally_release_assistant_lock "$ASSISTANT_NAME" "$$"
+    work_ally_die "Failed to start bridge"
+  fi
+  work_ally_write_channel_lock "$bridge_pid"
+  work_ally_write_assistant_lock "$ASSISTANT_NAME" "$bridge_pid"
+  notify_start_if_possible
+  work_ally_ok "work-ally started"
+  wait "$bridge_pid"
+}
+
+if [ "$FOREGROUND" = "1" ]; then
+  work_ally_stop_bridge_processes
+  stop_autosave_if_needed
+  run_bridge_foreground
+else
+  start_supervisor_background
+  if [ "$DID_START_NEW" = "1" ]; then
+    notify_start_if_possible
+    work_ally_ok "work-ally started"
+  else
+    work_ally_ok "work-ally already running"
+  fi
+fi

package/internal/modules/runtime/status.sh

@@ -0,0 +1,194 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck disable=SC1091
+. "$SCRIPT_DIR/../../lib/common.sh"
+work_ally_init_context
+if [ -z "${WORK_ALLY_ASSISTANT_NAME:-}" ]; then
+  WORK_ALLY_ASSISTANT_NAME=$(work_ally_resolve_assistant_name_from_args "$@" || true)
+fi
+if [ -n "${WORK_ALLY_ASSISTANT_NAME:-}" ]; then
+  work_ally_sync_workspace_root_from_assistant "$WORK_ALLY_ASSISTANT_NAME"
+  work_ally_hydrate_assistant_context "$WORK_ALLY_ASSISTANT_NAME"
+fi
+work_ally_ensure_state_dirs
+entry_install_root="${WORK_ALLY_INSTALL_ROOT:-}"
+entry_implementation_dir="${WORK_ALLY_IMPLEMENTATION_DIR:-}"
+entry_install_channel="${WORK_ALLY_INSTALL_CHANNEL:-unknown}"
+work_ally_load_env
+work_ally_load_assistant_state || true
+active_implementation_dir="${WORK_ALLY_IMPLEMENTATION_DIR:-}"
+active_install_channel="${WORK_ALLY_INSTALL_CHANNEL:-unknown}"
+
+if [ -n "${WORK_ALLY_ASSISTANT_NAME:-}" ] && work_ally_registry_has_assistant "$WORK_ALLY_ASSISTANT_NAME"; then
+  export WORK_ALLY_ASSISTANT_HOME="${WORK_ALLY_ASSISTANT_HOME:-$(work_ally_assistant_registered_home "$WORK_ALLY_ASSISTANT_NAME")}"
+  export WORK_ALLY_ASSISTANT_CODEX_HOME="${WORK_ALLY_ASSISTANT_CODEX_HOME:-$(work_ally_assistant_registered_codex_home "$WORK_ALLY_ASSISTANT_NAME")}"
+fi
+
+json_field() {
+  local file="$1"
+  local key="$2"
+  [ -f "$file" ] || return 0
+  sed -nE "s/.*\"${key}\"[[:space:]]*:[[:space:]]*\"([^\"]*)\".*/\\1/p" "$file" | head -n 1
+}
+
+json_number_field() {
+  local file="$1"
+  local key="$2"
+  [ -f "$file" ] || return 0
+  sed -nE "s/.*\"${key}\"[[:space:]]*:[[:space:]]*([0-9]+).*/\\1/p" "$file" | head -n 1
+}
+
+print_health_details() {
+  local name="$1"
+  local file="$2"
+  [ -f "$file" ] || return 0
+
+  local health_status updated owner listen workspace_root channel runtime pid
+  local delivery_status delivery_channel delivery_kind delivery_code delivery_message delivery_guidance
+  health_status=$(json_field "$file" status)
+  updated=$(json_field "$file" updated_at)
+  [ -n "$updated" ] || updated=$(json_field "$file" at)
+  owner=$(json_field "$file" owner)
+  listen=$(json_field "$file" listen)
+  workspace_root=$(json_field "$file" workspaceRoot)
+  channel=$(json_field "$file" channel)
+  runtime=$(json_field "$file" runtime)
+  pid=$(json_number_field "$file" pid)
+  delivery_status=$(json_field "$file" delivery_status)
+  delivery_channel=$(json_field "$file" delivery_channel)
+  delivery_kind=$(json_field "$file" delivery_error_kind)
+  delivery_code=$(json_field "$file" delivery_error_code)
+  delivery_message=$(json_field "$file" delivery_message)
+  delivery_guidance=$(json_field "$file" delivery_guidance)
+
+  local effective_status="${health_status:-unknown}"
+  if [ "$name" = "bridge" ]; then
+    local live_pids
+    live_pids=$(join_bridge_pids)
+    if { [ "$health_status" = "running" ] || [ "$health_status" = "degraded" ]; } \
+      && [ "$live_pids" = "none" ] \
+      && { [ -z "$pid" ] || ! work_ally_is_pid_alive "$pid"; }; then
+      effective_status="stale (${health_status})"
+    fi
+  fi
+  if [ "$name" = "supervisor" ]; then
+    local supervisor_state
+    supervisor_state=$(work_ally_process_status supervisor)
+    if [ "$health_status" = "running" ] && [[ "$supervisor_state" != running* ]]; then
+      effective_status="stale (${health_status})"
+    fi
+  fi
+
+  printf '%s health: %s\n' "$name" "$file"
+  printf '%s health status: %s\n' "$name" "$effective_status"
+  printf '%s health updated: %s\n' "$name" "${updated:-unknown}"
+  [ -n "$owner" ] && printf '%s owner: %s\n' "$name" "$owner"
+  [ -n "$listen" ] && printf '%s listen (health): %s\n' "$name" "$listen"
+  [ -n "$pid" ] && printf '%s pid (health): %s\n' "$name" "$pid"
+  [ -n "$workspace_root" ] && printf '%s workspace (health): %s\n' "$name" "$workspace_root"
+  [ -n "$channel" ] && printf '%s channel (health): %s\n' "$name" "$channel"
+  [ -n "$runtime" ] && printf '%s runtime (health): %s\n' "$name" "$runtime"
+  if [ "$name" = "bridge" ] && [ -n "$delivery_status" ]; then
+    printf '%s delivery status: %s\n' "$name" "$delivery_status"
+    [ -n "$delivery_channel" ] && printf '%s delivery channel: %s\n' "$name" "$delivery_channel"
+    [ -n "$delivery_kind" ] && printf '%s delivery issue: %s\n' "$name" "$delivery_kind"
+    [ -n "$delivery_code" ] && printf '%s delivery code: %s\n' "$name" "$delivery_code"
+    [ -n "$delivery_message" ] && printf '%s delivery message: %s\n' "$name" "$delivery_message"
+    [ -n "$delivery_guidance" ] && printf '%s delivery guidance: %s\n' "$name" "$delivery_guidance"
+  fi
+  return 0
+}
+
+pid_or_none() {
+  local file="$1"
+  local pid
+  pid=$(work_ally_read_pid "$file" || true)
+  printf '%s\n' "${pid:-none}"
+}
+
+join_bridge_pids() {
+  local pids
+  pids=$(work_ally_list_bridge_pids || true)
+  if [ -z "$pids" ]; then
+    printf 'none\n'
+    return 0
+  fi
+  printf '%s\n' "$pids" | awk 'NF' | paste -sd ',' -
+}
+
+print_channel_lock_details() {
+  local lock_file lock_status lock_workspace lock_pid
+  lock_file=$(work_ally_channel_lock_file || true)
+  [ -n "$lock_file" ] || return 0
+
+  lock_status=$(work_ally_channel_lock_status)
+  printf 'channel lock file: %s\n' "$lock_file"
+  printf 'channel lock status: %s\n' "$lock_status"
+
+  if [ -f "$lock_file" ]; then
+    lock_workspace=$(work_ally_channel_lock_field "$lock_file" workspace_root || true)
+    lock_pid=$(work_ally_channel_lock_field "$lock_file" pid || true)
+    [ -n "$lock_workspace" ] && printf 'channel lock workspace: %s\n' "$lock_workspace"
+    [ -n "$lock_pid" ] && printf 'channel lock pid: %s\n' "$lock_pid"
+  fi
+}
+
+print_assistant_lock_details() {
+  [ -n "${WORK_ALLY_ASSISTANT_NAME:-}" ] || return 0
+  local lock_file lock_status lock_workspace lock_pid
+  lock_file=$(work_ally_assistant_lock_file "$WORK_ALLY_ASSISTANT_NAME")
+  lock_status=$(work_ally_assistant_lock_status "$WORK_ALLY_ASSISTANT_NAME")
+  printf 'assistant lock file: %s\n' "$lock_file"
+  printf 'assistant lock status: %s\n' "$lock_status"
+  if [ -f "$lock_file" ]; then
+    lock_workspace=$(work_ally_assistant_lock_field "$lock_file" workspace_root || true)
+    lock_pid=$(work_ally_assistant_lock_field "$lock_file" pid || true)
+    [ -n "$lock_workspace" ] && printf 'assistant lock workspace: %s\n' "$lock_workspace"
+    [ -n "$lock_pid" ] && printf 'assistant lock pid: %s\n' "$lock_pid"
+  fi
+}
+
+supervisor_pid_file=$(work_ally_pid_file supervisor)
+bridge_pid_file=$(work_ally_pid_file bridge)
+autosave_pid_file=$(work_ally_pid_file assistant-autosave)
+supervisor_health=$(work_ally_health_file supervisor)
+bridge_health=$(work_ally_health_file bridge)
+autosave_health=$(work_ally_health_file assistant-autosave)
+
+printf 'mode: %s\n' "${WORK_ALLY_ASSISTANT_MODE:-native}"
+printf 'assistant: %s\n' "${WORK_ALLY_ASSISTANT_NAME:-none}"
+printf 'assistant home: %s\n' "${WORK_ALLY_ASSISTANT_HOME:-none}"
+printf 'assistant codex home: %s\n' "${WORK_ALLY_ASSISTANT_CODEX_HOME:-${CODEX_HOME:-none}}"
+if [ -n "${WORK_ALLY_ASSISTANT_HOME:-}" ]; then
+  printf 'assistant git remote: %s\n' "$(work_ally_assistant_git_origin_url "$WORK_ALLY_ASSISTANT_HOME" || true)"
+  printf 'assistant git branch: %s\n' "$(work_ally_assistant_git_branch "$WORK_ALLY_ASSISTANT_HOME")"
+fi
+
+printf 'workspace: %s\n' "$WORK_ALLY_WORKSPACE_ROOT"
+printf 'install channel: %s\n' "$entry_install_channel"
+printf 'implementation: %s\n' "$entry_implementation_dir"
+printf 'install root: %s\n' "$entry_install_root"
+if [ "$active_implementation_dir" != "$entry_implementation_dir" ] || [ "$active_install_channel" != "$entry_install_channel" ]; then
+  printf 'active install channel: %s\n' "$active_install_channel"
+  printf 'active implementation: %s\n' "$active_implementation_dir"
+fi
+printf 'state: %s\n' "$WORK_ALLY_STATE_DIR"
+printf 'supervisor: %s\n' "$(work_ally_process_status supervisor)"
+printf 'supervisor pid file: %s\n' "$supervisor_pid_file"
+printf 'supervisor pid: %s\n' "$(pid_or_none "$supervisor_pid_file")"
+print_health_details supervisor "$supervisor_health"
+
+printf 'bridge: %s\n' "$(work_ally_process_status bridge)"
+printf 'bridge pid file: %s\n' "$bridge_pid_file"
+printf 'bridge pid: %s\n' "$(pid_or_none "$bridge_pid_file")"
+printf 'bridge live pids: %s\n' "$(join_bridge_pids)"
+print_health_details bridge "$bridge_health"
+
+printf 'assistant autosave: %s\n' "$(work_ally_process_status assistant-autosave)"
+printf 'assistant autosave pid file: %s\n' "$autosave_pid_file"
+printf 'assistant autosave pid: %s\n' "$(pid_or_none "$autosave_pid_file")"
+print_health_details assistant-autosave "$autosave_health"
+print_channel_lock_details
+print_assistant_lock_details

package/internal/modules/runtime/stop.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck disable=SC1091
+. "$SCRIPT_DIR/../../lib/common.sh"
+work_ally_init_context
+if [ -z "${WORK_ALLY_ASSISTANT_NAME:-}" ]; then
+  WORK_ALLY_ASSISTANT_NAME=$(work_ally_resolve_assistant_name_from_args "$@" || true)
+fi
+if [ -n "${WORK_ALLY_ASSISTANT_NAME:-}" ]; then
+  work_ally_sync_workspace_root_from_assistant "$WORK_ALLY_ASSISTANT_NAME"
+  work_ally_hydrate_assistant_context "$WORK_ALLY_ASSISTANT_NAME"
+fi
+work_ally_ensure_state_dirs
+work_ally_load_env
+work_ally_load_assistant_state || true
+
+notify_stop_if_possible() {
+  if [ "${WORK_ALLY_CHANNEL_IMPL:-feishu}" != "feishu" ]; then
+    return 0
+  fi
+  if [ -z "${FEISHU_APP_ID:-}" ] || [ -z "${FEISHU_APP_SECRET:-}" ]; then
+    return 0
+  fi
+  node "$WORK_ALLY_IMPLEMENTATION_DIR/bridge/src/system-notify.ts" stop >/dev/null 2>&1 || true
+}
+
+stop_one() {
+  local name="$1"
+  local pid_file
+  pid_file=$(work_ally_pid_file "$name")
+
+  if [ ! -f "$pid_file" ]; then
+    return 0
+  fi
+
+  local pid
+  pid=$(work_ally_read_pid "$pid_file" || true)
+  if work_ally_is_pid_alive "$pid"; then
+    work_ally_terminate_pid "$pid"
+  fi
+  rm -f "$pid_file"
+  work_ally_write_health "$name" stopped '{}'
+}
+
+notify_stop_if_possible
+stop_one supervisor
+work_ally_stop_bridge_processes
+stop_one assistant-autosave
+if [ -n "${WORK_ALLY_ASSISTANT_HOME:-}" ]; then
+  work_ally_assistant_git_setup "$WORK_ALLY_ASSISTANT_HOME" "${WORK_ALLY_ASSISTANT_GIT_REMOTE:-}" || true
+  work_ally_assistant_git_checkpoint "$WORK_ALLY_ASSISTANT_HOME" "stop assistant ${WORK_ALLY_ASSISTANT_NAME:-unknown}" || true
+fi
+work_ally_ok "work-ally stopped"