loki-mode 11.3.9 → 11.5.1

package/autonomy/edit.sh

@@ -0,0 +1,242 @@
+#!/usr/bin/env bash
+# loki edit: the lightest path. One provider pass on the current repo.
+# No PRD, no plan stage, no council, no PR, no receipt (unless asked), no branch switching.
+# Functions-only file, sourced by autonomy/loki. Claude Code is the default provider.
+# Exit codes: 0 done, 1 provider or --verify failure, 2 usage or setup error.
+
+_loki_edit_usage() {
+    echo "Usage: loki edit [options] [path ...] \"<change>\""
+    echo ""
+    echo "One provider pass on the current repo. No PRD, plan, council, PR or branch switch."
+    echo "Prints git diff --stat, the diff (paged on a TTY), then cost and elapsed time."
+    echo ""
+    echo "Examples:"
+    echo "  loki edit \"rename fooBar to foo_bar in the config loader\""
+    echo "  loki edit src/foo.ts \"rename X to Y\""
+    echo "  loki edit --verify --commit src/a.ts src/b.ts \"add null checks\""
+    echo ""
+    echo "Options:"
+    echo "  --verify     Run the fast verify (loki verify --fast) after the edit"
+    echo "  --receipt    Write an unsigned edit receipt to .loki/edit-receipts/"
+    echo "  --commit     Commit the result with a generated message (stages only touched files)"
+    echo "  --dry-run    Plan only: read-only pass, no files are changed"
+    echo "  --quiet, -q  Print only the run summary block"
+    echo "  --json       Print only the run summary as one JSON object"
+    echo "  --help, -h   Show this help"
+    echo ""
+    echo "Leading arguments that are existing files or directories scope the edit to them."
+    echo "Environment: LOKI_EDIT_MODEL overrides the model."
+    echo "Exit codes: 0 done, 1 provider or verify failure, 2 usage or setup error."
+    echo ""
+    echo "edit = one pass, no loop. quick = small task with the verify loop (loki quick)."
+}
+
+# Run the edit, then print the unified run summary (autonomy/lib/run-summary.sh).
+# --quiet hides the diff and per-step lines; --json prints only the JSON summary.
+cmd_edit() {
+    local _q=false _j=false _a _t0 _sha _rc _lib _out _cost
+    for _a in "$@"; do
+        case "$_a" in --quiet|-q) _q=true ;; --json) _j=true ;; --) break ;; esac
+    done
+    case " $* " in *" --help "*|*" -h "*) _cmd_edit_run "$@"; return $? ;; esac
+    _t0="$(date +%s)"
+    _sha="$(git rev-parse HEAD 2>/dev/null || true)"
+    _LOKI_EDIT_COST_FILE="$(mktemp 2>/dev/null || true)"
+    export _LOKI_EDIT_COST_FILE
+    if [ "$_q" = true ] || [ "$_j" = true ]; then
+        _out="$(_cmd_edit_run "$@" 2>&1)"; _rc=$?
+        # Failures and usage errors stay visible even when quiet.
+        if [ "$_rc" -ne 0 ]; then printf '%s\n' "$_out" >&2; fi
+    else
+        _cmd_edit_run "$@"; _rc=$?
+    fi
+    _cost=""
+    if [ -n "${_LOKI_EDIT_COST_FILE:-}" ]; then
+        [ -s "$_LOKI_EDIT_COST_FILE" ] && _cost="$(head -n1 "$_LOKI_EDIT_COST_FILE")"
+        rm -f "$_LOKI_EDIT_COST_FILE"
+    fi
+    unset _LOKI_EDIT_COST_FILE
+    # Usage and setup errors (exit 2) never ran a pass: no summary.
+    if [ "$_rc" -ne 2 ]; then
+        _lib="${_LOKI_SCRIPT_DIR:-$(dirname "${BASH_SOURCE[0]}")}/lib/run-summary.sh"
+        if [ -f "$_lib" ]; then
+            # shellcheck source=lib/run-summary.sh
+            source "$_lib" 2>/dev/null || true
+            if command -v loki_run_summary >/dev/null 2>&1; then
+                _LOKI_SUMMARY_PRINTED=0
+                LOKI_SUMMARY_WORKTREE=1 LOKI_SUMMARY_COST="$_cost" SESSION_START_EPOCH="$_t0" \
+                LOKI_SUMMARY_JSON="$([ "$_j" = true ] && echo 1 || echo 0)" \
+                TARGET_DIR="." loki_run_summary "$_rc" "$_sha" || true
+            fi
+        fi
+    fi
+    return "$_rc"
+}
+
+_cmd_edit_run() {
+    local do_verify=false do_receipt=false do_commit=false dry=false
+    local paths=() change=""
+    local a
+    while [ $# -gt 0 ]; do
+        a="$1"
+        case "$a" in
+            --help|-h|help) _loki_edit_usage; return 0 ;;
+            --verify) do_verify=true ;;
+            --receipt) do_receipt=true ;;
+            --commit) do_commit=true ;;
+            --dry-run) dry=true ;;
+            --quiet|-q|--json) ;;
+            --) shift; change="$*"; break ;;
+            -*) echo "loki edit: unknown option: $a" >&2; _loki_edit_usage >&2; return 2 ;;
+            *)
+                if [ $# -gt 1 ] && [ -e "$a" ]; then
+                    paths+=("$a")
+                else
+                    change="$*"
+                    break
+                fi
+                ;;
+        esac
+        shift
+    done
+    if [ -z "$change" ]; then
+        echo "loki edit: no change description given" >&2
+        _loki_edit_usage >&2
+        return 2
+    fi
+    if ! git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+        echo "loki edit: not inside a git repository" >&2
+        return 2
+    fi
+    local prov="${LOKI_PROVIDER:-claude}"
+    if [ "$prov" != "claude" ]; then
+        echo "loki edit: provider '$prov' is not supported by the one-pass path; use loki quick, or unset LOKI_PROVIDER" >&2
+        return 2
+    fi
+    if ! command -v claude >/dev/null 2>&1; then
+        echo "loki edit: claude CLI not found (run loki doctor)" >&2
+        return 2
+    fi
+    if ! command -v python3 >/dev/null 2>&1; then
+        echo "loki edit: python3 is required" >&2
+        return 2
+    fi
+
+    local before_head before_status
+    before_head="$(git rev-parse HEAD 2>/dev/null || echo none)"
+    before_status="$(git status --porcelain)"
+
+    local prompt scope=""
+    if [ "${#paths[@]}" -gt 0 ]; then
+        scope=" Limit changes to these paths: ${paths[*]}."
+    fi
+    if [ "$dry" = true ]; then
+        prompt="Plan only, do not modify any file. Describe the exact edits (file, location, change) needed for: ${change}.${scope}"
+    else
+        prompt="Make this change in the current repository with the smallest correct edit: ${change}.${scope} Do not create branches, commits, plans or documents. Reply with one short sentence."
+    fi
+
+    local args=(-p "$prompt" --output-format json)
+    if [ "$dry" = true ]; then
+        args+=(--permission-mode plan)
+    else
+        args+=(--permission-mode acceptEdits --allowedTools "Read Edit Write Glob Grep")
+    fi
+    [ -n "${LOKI_EDIT_MODEL:-}" ] && args+=(--model "$LOKI_EDIT_MODEL")
+
+    local start_s out rc
+    start_s="$(date +%s)"
+    out="$(LOKI_NO_BROWSER=1 claude "${args[@]}" 2>&1)"
+    rc=$?
+    local elapsed=$(( $(date +%s) - start_s ))
+
+    local parsed
+    parsed="$(printf '%s' "$out" | python3 -c '
+import json,sys
+raw=sys.stdin.read()
+try:
+    d=json.loads(raw)
+except Exception:
+    print("0|1|"+raw.strip()[:400].replace("\n"," ")); sys.exit(0)
+c=d.get("total_cost_usd",d.get("cost_usd",0)) or 0
+err=1 if d.get("is_error") else 0
+print("%s|%s|%s" % (c,err,(d.get("result") or "").strip().replace("\n"," ")[:400]))
+' 2>/dev/null)"
+    local cost="0" iserr="1" msg="" rest=""
+    case "$parsed" in
+        *'|'*'|'*) cost="${parsed%%|*}"; rest="${parsed#*|}"; iserr="${rest%%|*}"; msg="${rest#*|}" ;;
+        *) msg="$parsed" ;;
+    esac
+
+    [ -n "${_LOKI_EDIT_COST_FILE:-}" ] && printf '%s\n' "$cost" > "$_LOKI_EDIT_COST_FILE" 2>/dev/null
+    if [ "$rc" -ne 0 ] || [ "$iserr" = "1" ]; then
+        echo "loki edit: provider pass failed (exit $rc)" >&2
+        [ -n "$msg" ] && echo "$msg" >&2
+        return 1
+    fi
+
+    if [ "$dry" = true ]; then
+        [ -n "$msg" ] && echo "$msg"
+        printf 'dry-run: no files changed | cost $%s | %ss\n' "$cost" "$elapsed"
+        return 0
+    fi
+
+    # Files touched by this pass: status delta against the pre-run snapshot.
+    local touched
+    touched="$(git status --porcelain | grep -vxF -f <(printf '%s\n' "$before_status") 2>/dev/null | sed 's/^...//' || true)"
+    [ -n "$touched" ] || touched="$(git diff --name-only)"
+
+    if [ -z "$touched" ]; then
+        echo "No changes made. ${msg}"
+        printf 'cost $%s | %ss\n' "$cost" "$elapsed"
+        return 0
+    fi
+
+    git --no-pager diff --stat
+    if [ -t 1 ]; then git diff; else git --no-pager diff; fi
+    [ -n "$msg" ] && echo "$msg"
+
+    local vrc=0
+    if [ "$do_verify" = true ]; then
+        local fv="${_LOKI_SCRIPT_DIR:-$(dirname "${BASH_SOURCE[0]}")}/lib/fast_verify.py"
+        if [ -f "$fv" ]; then
+            python3 "$fv" || vrc=$?
+        else
+            echo "loki edit: fast_verify not found at $fv" >&2
+            vrc=2
+        fi
+        if [ "$vrc" -eq 0 ]; then echo "verify: pass"; else echo "verify: FAILED (exit $vrc)" >&2; fi
+    fi
+
+    if [ "$do_receipt" = true ]; then
+        local rdir=".loki/edit-receipts" ts rf
+        ts="$(date -u +%Y%m%dT%H%M%SZ)"
+        mkdir -p "$rdir"
+        rf="$rdir/edit-$ts.json"
+        git diff | python3 -c '
+import hashlib,json,sys
+d=sys.stdin.buffer.read()
+json.dump({"kind":"edit-receipt","signed":False,"task":sys.argv[1],"base":sys.argv[2],"diff_sha256":hashlib.sha256(d).hexdigest(),"cost_usd":float(sys.argv[3] or 0),"elapsed_s":int(sys.argv[4]),"verify_exit":int(sys.argv[5])},open(sys.argv[6],"w"),indent=2)
+' "$change" "$before_head" "$cost" "$elapsed" "$vrc" "$rf"
+        echo "receipt: $rf (unsigned)"
+    fi
+
+    if [ "$do_commit" = true ]; then
+        if [ "$vrc" -ne 0 ]; then
+            echo "loki edit: not committing because verify failed" >&2
+        else
+            local subj f
+            subj="$(printf '%s' "$change" | tr '\n' ' ' | cut -c1-68)"
+            while IFS= read -r f; do
+                [ -n "$f" ] && git add -- "$f"
+            done <<< "$touched"
+            if git commit -q -m "edit: $subj" -m "Generated by loki edit."; then
+                echo "committed: $(git rev-parse --short HEAD)"
+            fi
+        fi
+    fi
+
+    printf 'cost $%s | %ss\n' "$cost" "$elapsed"
+    [ "$vrc" -eq 0 ] || return 1
+    return 0
+}

package/autonomy/lib/chat.sh

@@ -0,0 +1,315 @@
+#!/usr/bin/env bash
+# loki chat: interactive Plan/Build REPL. Claude Code is the default provider.
+# Sourced by autonomy/loki; defines cmd_chat. Free text goes to the provider
+# in the current mode; slash commands delegate to existing loki commands.
+
+_LOKI_CHAT_SYSTEM_PROMPT="You are running inside Loki Mode chat. Be concise. Prefer small, verifiable changes. Loki commands available to the user: loki start, loki quick, loki verify, loki receipt, loki undo."
+
+_chat_loki_bin() {
+    local d="${_LOKI_SCRIPT_DIR:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}"
+    if [ -x "$d/../bin/loki" ]; then echo "$d/../bin/loki"
+    elif command -v loki >/dev/null 2>&1; then command -v loki
+    else echo "$d/loki"; fi
+}
+
+_chat_help() {
+    cat <<'HLP'
+Loki chat commands:
+  /plan              read-only mode (no edits)
+  /build             edit mode
+  /run <prd|brief>   loki start with this session's model and provider (same run as the shell)
+  /attach            attach to the current or most recent loki start run in this repo
+  /quick <task>      loki quick
+  /edit <change>     apply one change (build mode for this turn)
+  /verify            loki verify
+  /receipt           loki receipt
+  /model <id>        set model for this session
+  /provider <name>   switch provider (claude, codex, cline, aider, opencode)
+  /cost              loki cost
+  /diff              git diff --stat plus diff
+  /undo [args]       loki undo
+  /help, /exit
+Attached mode (loki chat --attach or /attach): /status /steer <msg> /diff /verify /receipt /stop
+  /detach returns to normal chat. Free text asks the provider about the run (state and log tail as context).
+Anything else is sent to the current provider in the current mode.
+HLP
+}
+
+
+# Run a delegate without letting a non-zero exit end the session (autonomy/loki runs under set -e).
+_chat_do() { local _rc=0; "$@" || _rc=$?; [ "$_rc" -eq 0 ] || echo "(exit $_rc)"; return 0; }
+
+# Newest loki start run in this repo: engine10 run dir first, then legacy session state.
+_chat_run_dir() {
+    local root="${LOKI_DIR:-.loki}" d newest=""
+    for d in "$root"/runs/e10-*/; do [ -d "$d" ] && newest="${d%/}"; done
+    echo "$newest"
+}
+
+# True when the pid file at $1 holds a live pid (plain number or run.pid JSON).
+_chat_pidfile_live() {
+    local f="$1" pid
+    [ -f "$f" ] || return 1
+    pid="$(head -n1 "$f" 2>/dev/null | tr -d '[:space:]')"
+    case "$pid" in
+        '{'*) pid="$(printf '%s' "$pid" | sed -n 's/.*"pid":\([0-9][0-9]*\).*/\1/p')" ;;
+    esac
+    case "$pid" in ''|*[!0-9]*) return 1 ;; esac
+    kill -0 "$pid" 2>/dev/null
+}
+
+# Same sources loki status reads (list_running_sessions: loki.pid, sessions/*/loki.pid,
+# run-*.pid; PAUSE/STOP signals; session.json) plus the engine10 run.pid the supervisor
+# writes in the run dir and removes on every exit path. No events.jsonl guessing.
+_chat_run_state() {
+    local root="${LOKI_DIR:-.loki}" rd="$1" f st="" live=0
+    if [ -n "$rd" ] && _chat_pidfile_live "$rd/run.pid"; then live=1; fi
+    if _chat_pidfile_live "$root/loki.pid"; then live=1; fi
+    for f in "$root"/sessions/*/loki.pid "$root"/run-*.pid; do
+        if _chat_pidfile_live "$f"; then live=1; fi
+    done
+    if [ "$live" = "1" ]; then
+        if [ -f "$root/PAUSE" ]; then echo paused; else echo running; fi
+        return
+    fi
+    if [ -f "$root/STOP" ] || [ -f "$root/STOPPED" ]; then echo stopped; return; fi
+    if [ -f "$root/session.json" ]; then
+        st="$(sed -n 's/.*"status"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$root/session.json" 2>/dev/null | head -n1)"
+        case "$st" in running|paused|stopped) echo "$st (no live process)"; return ;; esac
+    fi
+    echo finished
+}
+
+# Context block for free-text questions in attached mode: state plus the log tail.
+_chat_attach_context() {
+    local root="${LOKI_DIR:-.loki}" rd lf
+    rd="$(_chat_run_dir)"
+    printf 'Run state: %s\n' "$(_chat_run_state "$rd")"
+    [ -n "$rd" ] && printf 'Run dir: %s\n' "$rd"
+    [ -f "$root/state/provider" ] && printf 'Provider: %s\n' "$(head -n1 "$root/state/provider" 2>/dev/null)"
+    if [ -n "$rd" ] && [ -f "$rd/events.jsonl" ]; then
+        printf 'Last events:\n'; tail -n 20 "$rd/events.jsonl" 2>/dev/null | cut -c1-300
+    fi
+    # shellcheck disable=SC2012
+    lf="$(ls -t "$root"/logs/*.log 2>/dev/null | head -n1 || true)"
+    if [ -n "$lf" ]; then printf 'Log tail (%s):\n' "$lf"; tail -n 40 "$lf" 2>/dev/null | cut -c1-300; fi
+}
+
+_chat_attach_banner() {
+    local rd; rd="$(_chat_run_dir)"
+    if [ ! -d "${LOKI_DIR:-.loki}" ]; then
+        echo "No .loki state here. Start a run with: loki start <prd|brief>"; return 1
+    fi
+    echo "Attached to ${rd:+$(basename "$rd")}${rd:-the current session} ($(_chat_run_state "$rd")). /status /steer /diff /verify /receipt /stop /detach"
+}
+
+# _chat_send <mode> <text>: one turn against the active provider.
+_chat_send() {
+    local mode="$1" text="$2"
+    if [ "$_CHAT_PROVIDER" = "claude" ]; then
+        command -v claude >/dev/null 2>&1 || { echo "loki chat: claude CLI not found. Fix (same as loki doctor):" >&2; _loki_req_fix_line claude >&2; return 1; }
+        local -a args=(-p "$text" --append-system-prompt "$_LOKI_CHAT_SYSTEM_PROMPT")
+        if [ "$mode" = "plan" ]; then args+=(--permission-mode plan); else args+=(--permission-mode acceptEdits); fi
+        [ -n "$_CHAT_MODEL" ] && args+=(--model "$_CHAT_MODEL")
+        [ "$_CHAT_STARTED" = "1" ] && args+=(--continue)
+        claude "${args[@]}" || return $?
+        _CHAT_STARTED=1
+        return 0
+    fi
+    local prompt="$text"
+    if [ "$mode" = "plan" ]; then
+        prompt="PLAN MODE: analyze and propose only. Do NOT modify any files. Request: $text"
+    fi
+    if [ "$mode" != "plan" ]; then
+        (
+            # shellcheck disable=SC1091
+            source "${_LOKI_SCRIPT_DIR:-.}/../providers/loader.sh" 2>/dev/null || exit 1
+            load_provider "$_CHAT_PROVIDER" >/dev/null 2>&1 || { echo "loki chat: cannot load provider $_CHAT_PROVIDER" >&2; exit 1; }
+            provider_invoke "$prompt"
+        )
+        return $?
+    fi
+    # Plan mode: read-only via the provider's native flags, then a post-turn guard
+    # that reverts any change the provider made anyway.
+    local rc=0
+    _chat_plan_snapshot
+    (
+        # shellcheck disable=SC1091
+        source "${_LOKI_SCRIPT_DIR:-.}/../providers/loader.sh" 2>/dev/null || exit 1
+        load_provider "$_CHAT_PROVIDER" >/dev/null 2>&1 || { echo "loki chat: cannot load provider $_CHAT_PROVIDER" >&2; exit 1; }
+        case "$_CHAT_PROVIDER" in
+            codex) codex exec --sandbox read-only --skip-git-repo-check "$prompt" < /dev/null ;;
+            opencode) opencode run --agent plan --model "$PROVIDER_MODEL_DEVELOPMENT" "$prompt" < /dev/null ;;
+            aider) aider --message "$prompt" --yes-always --no-auto-commits --dry-run --model "$AIDER_DEFAULT_MODEL" < /dev/null 2>&1 ;;
+            cline) cline --plan "$prompt" < /dev/null ;;
+            *) provider_invoke "$prompt" ;;
+        esac
+    ) || rc=$?
+    _chat_plan_guard
+    return "$rc"
+}
+
+# Plan-mode snapshot: tracked state as a tree-ish commit (git stash create does not
+# touch the stash stack; empty output means clean, so HEAD is the base) plus the
+# list of untracked files.
+_CHAT_PLAN_BASE=""
+_CHAT_PLAN_UNTRACKED=""
+_CHAT_PLAN_ARMED=0
+_chat_plan_snapshot() {
+    _CHAT_PLAN_ARMED=0
+    git rev-parse --is-inside-work-tree >/dev/null 2>&1 || return 0
+    _CHAT_PLAN_BASE="$(git stash create 2>/dev/null || true)"
+    [ -n "$_CHAT_PLAN_BASE" ] || _CHAT_PLAN_BASE="$(git rev-parse HEAD 2>/dev/null || true)"
+    [ -n "$_CHAT_PLAN_BASE" ] || return 0
+    _CHAT_PLAN_UNTRACKED="$(git ls-files -o --exclude-standard 2>/dev/null | sort)"
+    _CHAT_PLAN_ARMED=1
+}
+
+_chat_plan_guard() {
+    [ "$_CHAT_PLAN_ARMED" = "1" ] || return 0
+    local f changed=0 now
+    while IFS= read -r f; do
+        [ -n "$f" ] || continue
+        changed=1
+        if git cat-file -e "${_CHAT_PLAN_BASE}:${f}" 2>/dev/null; then
+            git checkout "$_CHAT_PLAN_BASE" -- "$f" 2>/dev/null || true
+        else
+            git rm -f -q --cached -- "$f" 2>/dev/null || true
+            rm -f -- "$f"
+        fi
+    done < <(git diff --name-only "$_CHAT_PLAN_BASE" 2>/dev/null)
+    now="$(git ls-files -o --exclude-standard 2>/dev/null | sort)"
+    while IFS= read -r f; do
+        [ -n "$f" ] || continue
+        printf '%s\n' "$_CHAT_PLAN_UNTRACKED" | grep -Fxq -- "$f" && continue
+        changed=1
+        rm -f -- "$f"
+    done <<EOF
+$now
+EOF
+    _CHAT_PLAN_ARMED=0
+    if [ "$changed" = "1" ]; then
+        echo "loki chat: plan mode is read-only; the provider changed files, and those changes were reverted. Use /build to allow edits."
+    fi
+    return 0
+}
+
+# /run: the exact run the shell would give: loki start with this session's provider and model.
+# The summary prints at the end of the run; chat stays open afterwards.
+_chat_run_start() {
+    local loki="$1" input="$2" rc=0 t0=$SECONDS
+    local -a args=("start" "$input" --provider "$_CHAT_PROVIDER")
+    [ -n "$_CHAT_MODEL" ] && args+=(--model "$_CHAT_MODEL")
+    "$loki" "${args[@]}" || rc=$?
+    # HANDOFF: same file loki start wrote, so chat and the shell show one review view
+    # (only when written during this run; a stale file from an earlier run is never shown)
+    if [ -f ".loki/review/HANDOFF.md" ] && [ -n "$(find ".loki/review/HANDOFF.md" -mmin "-$(( (SECONDS - t0) / 60 + 1 ))" 2>/dev/null)" ]; then cat ".loki/review/HANDOFF.md"; fi
+    echo "(run finished, exit $rc; chat is still open)"
+    return 0
+}
+
+cmd_chat() {
+    local tui=0 attach=0
+    while [ $# -gt 0 ]; do
+        case "$1" in
+            --tui) tui=1 ;;
+            --attach) attach=1 ;;
+            --help|-h)
+                echo "Usage: loki chat [--tui] [--attach]"
+                echo "  Interactive Plan/Build session. --tui execs the claude CLI with Loki context."
+                echo "  --attach joins the current or most recent 'loki start' run in this repo."
+                echo "  'loki start' is the primary path; /run inside chat runs the same thing."
+                _chat_help
+                return 0 ;;
+            *) echo "loki chat: unknown option: $1" >&2; return 2 ;;
+        esac
+        shift
+    done
+
+    if [ "$tui" = "1" ]; then
+        command -v claude >/dev/null 2>&1 || { echo "loki chat: claude CLI not found. Fix (same as loki doctor):" >&2; _loki_req_fix_line claude >&2; return 1; }
+        local -a targs=(--append-system-prompt "$_LOKI_CHAT_SYSTEM_PROMPT")
+        [ -n "${LOKI_MODEL:-}" ] && targs+=(--model "$LOKI_MODEL")
+        exec claude "${targs[@]}"
+    fi
+
+    if [ ! -t 0 ]; then
+        echo "loki chat needs an interactive terminal (use loki quick for one-shot tasks)" >&2
+        return 2
+    fi
+
+    local loki; loki="$(_chat_loki_bin)"
+    local mode="plan" line cmd rest
+    _CHAT_PROVIDER="${LOKI_PROVIDER:-claude}"
+    _CHAT_MODEL="${LOKI_MODEL:-}"
+    _CHAT_STARTED=0
+    local attached=0
+    echo "Loki chat (provider: $_CHAT_PROVIDER). /help for commands, /exit to quit."
+    if [ "$attach" = "1" ]; then _chat_attach_banner && attached=1; fi
+    while true; do
+        local plabel="$mode"; [ "$attached" = "1" ] && plabel="attached"
+        if ! IFS= read -r -e -p "loki[$plabel]> " line; then echo; break; fi
+        [ -n "$line" ] || continue
+        case "$line" in
+            /*) cmd="${line%% *}"; rest=""; [ "$cmd" != "$line" ] && rest="${line#* }" ;;
+            *)
+                if [ "$attached" = "1" ]; then
+                    _chat_send plan "You are answering questions about a running or finished Loki run. Read-only: do not modify files. Context:
+$(_chat_attach_context)
+
+Question: $line" || true
+                else
+                    _chat_send "$mode" "$line" || true
+                fi
+                continue ;;
+        esac
+        if [ "$attached" = "1" ]; then
+            case "$cmd" in
+                /status) _chat_do "$loki" status; continue ;;
+                /steer)
+                    [ -n "$rest" ] || { echo "usage: /steer <message>"; continue; }
+                    _chat_do "$loki" steer "$rest"; continue ;;
+                /stop) _chat_do "$loki" stop; continue ;;
+                /detach) attached=0; echo "Detached."; continue ;;
+            esac
+        fi
+        case "$cmd" in
+            /exit|/quit) break ;;
+            /help) _chat_help ;;
+            /plan) mode="plan"; echo "Plan mode: read-only." ;;
+            /build) mode="build"; echo "Build mode: edits allowed." ;;
+            /run)
+                [ -n "$rest" ] || { echo "usage: /run <prd|brief>"; continue; }
+                _chat_run_start "$loki" "$rest"
+                _chat_attach_banner || true ;;
+            /attach) _chat_attach_banner && attached=1 ;;
+            /status) _chat_do "$loki" status ;;
+            /steer)
+                [ -n "$rest" ] || { echo "usage: /steer <message>"; continue; }
+                _chat_do "$loki" steer "$rest" ;;
+            /stop) _chat_do "$loki" stop ;;
+            /detach) echo "Not attached." ;;
+            /quick)
+                [ -n "$rest" ] || { echo "usage: /quick <task>"; continue; }
+                _chat_do "$loki" quick "$rest" ;;
+            /edit)
+                [ -n "$rest" ] || { echo "usage: /edit <change>"; continue; }
+                _chat_send build "$rest" ;;
+            /verify) _chat_do "$loki" verify ;;
+            /receipt) _chat_do "$loki" receipt ;;
+            /cost) _chat_do "$loki" cost ;;
+            /undo) # shellcheck disable=SC2086
+                _chat_do "$loki" undo $rest ;;
+            /diff) _chat_do git diff --stat; _chat_do git diff ;;
+            /model)
+                if [ -n "$rest" ]; then _CHAT_MODEL="$rest"; echo "model: $rest"; else echo "model: ${_CHAT_MODEL:-default}"; fi ;;
+            /provider)
+                case "$rest" in
+                    claude|codex|cline|aider|opencode) _CHAT_PROVIDER="$rest"; _CHAT_STARTED=0; echo "provider: $rest" ;;
+                    *) echo "usage: /provider claude|codex|cline|aider|opencode (now: $_CHAT_PROVIDER)" ;;
+                esac ;;
+            *) echo "unknown command: $cmd (try /help)" ;;
+        esac
+    done
+    return 0
+}

package/autonomy/lib/engine10-push.sh

@@ -95,6 +95,14 @@ _e10_local_push() {
         log_warn "Not pushing branch '$branch': it is (or may be) the default branch of $origin."
         return 2
     fi
+    # RECOVERY: remote already at the local commit means a prior attempt landed; push nothing.
+    local want have
+    want="$(_e10_git -C "$dir" rev-parse -q --verify "refs/heads/$branch" 2>/dev/null)" || want=""
+    have="$(_e10_git ls-remote "$origin" "refs/heads/$branch" 2>/dev/null | awk '{print $1; exit}')" || have=""
+    if [ -n "$want" ] && [ "$want" = "$have" ]; then
+        log_info "push skipped: remote already has $branch at ${want:0:12}"
+        return 0
+    fi
     tmp="$(mktemp -d "${TMPDIR:-/tmp}/loki-push.XXXXXX")" || return 1
     if _e10_git init -q --template= "$tmp" >/dev/null 2>&1 \
         && _e10_git -C "$tmp" fetch -q --no-tags --update-shallow "$dir" \
@@ -138,7 +146,17 @@ case "$mode" in
             printf 'local://%s#%s\n' "$_LOKI_PINNED_ORIGIN" "$branch"
             exit 0
         fi
-        _loki_trusted_push _loki_with_github_tokens "$dir" "$branch" || die "push refused or failed (rc=$?)"
+        # RECOVERY: a resumed publish skips the push when the remote branch is already at the local commit.
+        _e10_want="$(_e10_git -C "$dir" rev-parse -q --verify "refs/heads/$branch" 2>/dev/null)" || _e10_want=""
+        _e10_have=""
+        case "$branch" in main | master | HEAD) ;; *)
+            _e10_have="$(_e10_gh api "repos/$_e10_repo/git/ref/heads/$branch" --jq .object.sha 2>/dev/null)" || _e10_have="" ;;
+        esac
+        if [ -n "$_e10_want" ] && [ "$_e10_want" = "$_e10_have" ]; then
+            log_info "push skipped: remote already has $branch at ${_e10_want:0:12}"
+        else
+            _loki_trusted_push _loki_with_github_tokens "$dir" "$branch" || die "push refused or failed (rc=$?)"
+        fi
         url="$(_e10_gh pr list --repo "$_e10_repo" --head "$branch" --state open --json url --jq '.[0].url')" \
             || die "gh pr list failed"
         if [ -z "$url" ] || [ "$url" = "null" ]; then