loki-mode 7.12.0 → 7.14.0

package/autonomy/loki

@@ -13111,6 +13111,9 @@ main() {
         checkpoint|cp)
             cmd_checkpoint "$@"
             ;;
+        rollback)
+            cmd_rollback "$@"
+            ;;
         council)
             cmd_council "$@"
             ;;
@@ -13205,6 +13208,9 @@ main() {
         docs)
             cmd_docs "$@"
             ;;
+        wiki)
+            cmd_wiki "$@"
+            ;;
         magic)
             cmd_magic "$@"
             ;;
@@ -16435,12 +16441,19 @@ SHOW_EOF
             local restored=0
             for item in "$cp_dir"/*; do
                 [ -e "$item" ] || continue
-                local name=$(basename "$item")
+                local name
+                name=$(basename "$item")
                 [ "$name" = "metadata.json" ] && continue
+                # R6: do not restore the worktree-snapshot sidecar as state.
+                [ "$name" = "worktree-snapshot.txt" ] && continue
 
                 if [ -d "$item" ]; then
-                    rm -rf ".loki/$name"
-                    cp -r "$item" ".loki/$name" 2>/dev/null && restored=$((restored + 1))
+                    # R6 data-loss fix: NEVER `rm -rf ".loki/$name"` -- the
+                    # checkpoint store lives under .loki/state/checkpoints/, so
+                    # blowing away .loki/state/ would destroy every checkpoint
+                    # (including this one). Merge-copy directory contents instead.
+                    mkdir -p ".loki/$name"
+                    cp -r "$item"/. ".loki/$name"/ 2>/dev/null && restored=$((restored + 1))
                 else
                     cp "$item" ".loki/$name" 2>/dev/null && restored=$((restored + 1))
                 fi
@@ -16448,17 +16461,28 @@ SHOW_EOF
 
             echo -e "  Restored: ${GREEN}$restored${NC} state items from $cp_id"
 
-            # Show git info for manual code rollback
-            local cp_sha=$(_CP_METADATA="$metadata" python3 -c "import json, os; d=json.load(open(os.environ['_CP_METADATA'])); print(d.get('git_sha','unknown'))" 2>/dev/null)
-            if [ -n "$cp_sha" ] && [ "$cp_sha" != "unknown" ] && [ "$cp_sha" != "not-a-git-repo" ]; then
+            # Show how to also restore code. R6: prefer the anchored working-tree
+            # snapshot over `git reset --hard <git_sha>`. git_sha is HEAD (the last
+            # commit), and Loki does not commit per iteration, so a hard reset
+            # discards the iteration's work instead of reconstructing it -- the old
+            # hint was misleading.
+            if git rev-parse --verify "refs/loki/cp/${cp_id}" >/dev/null 2>&1; then
                 echo ""
-                echo -e "  ${YELLOW}Note:${NC} Session state has been restored, but code is unchanged."
-                echo "  To also roll back code to the checkpoint's git state:"
+                echo -e "  ${YELLOW}Note:${NC} Session state restored. Code is unchanged."
+                echo "  To also restore the working tree to this checkpoint's snapshot:"
                 echo ""
-                echo -e "    ${DIM}git reset --hard ${cp_sha:0:8}${NC}"
+                echo -e "    ${DIM}git stash apply refs/loki/cp/${cp_id}${NC}"
                 echo ""
-                echo -e "  ${RED}Warning:${NC} git reset --hard will discard uncommitted changes."
-                echo "  Consider 'git stash' first to preserve current work."
+                echo -e "  ${DIM}(restores tracked files; newly-added files are not removed)${NC}"
+            else
+                local cp_sha
+                cp_sha=$(_CP_METADATA="$metadata" python3 -c "import json, os; d=json.load(open(os.environ['_CP_METADATA'])); print(d.get('git_sha','unknown'))" 2>/dev/null)
+                if [ -n "$cp_sha" ] && [ "$cp_sha" != "unknown" ] && [ "$cp_sha" != "not-a-git-repo" ]; then
+                    echo ""
+                    echo -e "  ${YELLOW}Note:${NC} Session state restored, but no working-tree snapshot"
+                    echo "  was captured for this checkpoint, so code changes since the last"
+                    echo -e "  commit (${cp_sha:0:8}) are not restorable from here."
+                fi
             fi
             ;;
 
@@ -16494,6 +16518,157 @@ SHOW_EOF
     esac
 }
 
+# R6: one-command rollback. Top-level, obvious entry point that mirrors the Bun
+# `loki rollback` subcommands (list/show/to/latest) so both routes are at parity.
+# Restore is destructive on .loki/ state, so it ALWAYS captures a forced
+# pre-rollback snapshot first (re-undoability invariant) and then glob-restores
+# whatever the checkpoint dir contains (works across all three checkpoint writers).
+cmd_rollback() {
+    local subcommand="${1:-help}"
+    shift 2>/dev/null || true
+
+    local checkpoints_dir=".loki/state/checkpoints"
+    local index_file="$checkpoints_dir/index.jsonl"
+
+    # Resolve the most recent checkpoint id from on-disk cp-*/chk-* dirs, sorted
+    # by mtime (newest last). Mirrors the Bun "latest = last entry" semantics but
+    # is robust to the three differing id formats.
+    _rollback_latest_id() {
+        [ -d "$checkpoints_dir" ] || return 1
+        ls -1dt "$checkpoints_dir"/*/ 2>/dev/null | head -1 | sed 's#/$##' | xargs -I{} basename {} 2>/dev/null
+    }
+
+    # Force a pre-rollback snapshot of current state, then glob-restore the target.
+    # Delegates the actual restore to `cmd_checkpoint rollback`, which already
+    # glob-restores and is shared with the manual path (no duplication).
+    _rollback_restore() {
+        local target_id="$1"
+        local want_code="$2"
+
+        # Validate id (defense in depth; cmd_checkpoint validates again).
+        if [[ ! "$target_id" =~ ^[a-zA-Z0-9_-]+$ ]]; then
+            echo -e "${RED}Error: Invalid checkpoint ID${NC}"
+            return 1
+        fi
+        if [ ! -d "$checkpoints_dir/$target_id" ]; then
+            echo -e "${RED}Error: Checkpoint not found: $target_id${NC}"
+            echo "Run 'loki rollback list' to see available checkpoints."
+            return 1
+        fi
+
+        # Re-undoability: snapshot current state before overwriting it.
+        local pre_id
+        pre_id="rb-pre-$(date -u '+%Y%m%d-%H%M%S')"
+        local pre_dir="$checkpoints_dir/$pre_id"
+        mkdir -p "$pre_dir"
+        local saved=0
+        for item in .loki/session.json .loki/dashboard-state.json .loki/CONTINUITY.md .loki/autonomy-state.json .loki/state .loki/queue; do
+            if [ -e "$item" ]; then
+                cp -r "$item" "$pre_dir/" 2>/dev/null && saved=$((saved + 1))
+            fi
+        done
+        _RB_PID="$pre_id" _RB_TS="$(date -u '+%Y-%m-%dT%H:%M:%SZ')" _RB_DIR="$pre_dir" \
+        _RB_INDEX="$index_file" _RB_CHKDIR="$checkpoints_dir" python3 << 'RB_PRE_EOF' 2>/dev/null || true
+import json, os
+meta = {"id": os.environ["_RB_PID"], "timestamp": os.environ["_RB_TS"],
+        "message": "pre-rollback snapshot", "created_by": "loki rollback"}
+d = os.environ["_RB_DIR"]
+os.makedirs(d, exist_ok=True)
+with open(os.path.join(d, "metadata.json"), "w") as f:
+    json.dump(meta, f, indent=2)
+os.makedirs(os.environ["_RB_CHKDIR"], exist_ok=True)
+with open(os.environ["_RB_INDEX"], "a") as f:
+    f.write(json.dumps({"id": meta["id"], "timestamp": meta["timestamp"], "message": meta["message"]}) + "\n")
+RB_PRE_EOF
+        echo -e "  ${DIM}Saved prior state as ${pre_id} (undo this rollback with: loki rollback to ${pre_id})${NC}"
+
+        # Perform the actual state restore via the shared glob-restore path.
+        cmd_checkpoint rollback "$target_id"
+
+        # Optional code restore from the anchored working-tree snapshot.
+        if [ "$want_code" = "1" ]; then
+            if git rev-parse --verify "refs/loki/cp/${target_id}" >/dev/null 2>&1; then
+                echo ""
+                echo -e "  ${YELLOW}Restoring working tree from snapshot refs/loki/cp/${target_id}...${NC}"
+                if git stash apply "refs/loki/cp/${target_id}" 2>/dev/null; then
+                    echo -e "  ${GREEN}Working tree restored.${NC} (tracked files only; newly-added files were not removed)"
+                else
+                    echo -e "  ${RED}Could not apply snapshot cleanly.${NC} Resolve conflicts, or run: git stash apply refs/loki/cp/${target_id}"
+                fi
+            else
+                echo ""
+                echo -e "  ${YELLOW}No working-tree snapshot anchored for ${target_id}; code not restored.${NC}"
+            fi
+        fi
+    }
+
+    case "$subcommand" in
+        list|ls)
+            cmd_checkpoint list
+            ;;
+        show)
+            cmd_checkpoint show "$@"
+            ;;
+        to)
+            local target="${1:-}"
+            local want_code=0
+            shift 2>/dev/null || true
+            for a in "$@"; do [ "$a" = "--code" ] && want_code=1; done
+            if [ -z "$target" ]; then
+                echo -e "${RED}Error: Specify a checkpoint ID${NC}"
+                echo "Usage: loki rollback to <id> [--code]"
+                echo "Run 'loki rollback list' to see available checkpoints."
+                return 1
+            fi
+            echo -e "${BOLD}Rolling back to checkpoint: $target${NC}"
+            echo ""
+            _rollback_restore "$target" "$want_code"
+            ;;
+        latest)
+            local want_code=0
+            for a in "$@"; do [ "$a" = "--code" ] && want_code=1; done
+            local latest_id
+            latest_id=$(_rollback_latest_id)
+            if [ -z "$latest_id" ]; then
+                echo -e "${RED}No checkpoints found to roll back to.${NC}"
+                return 1
+            fi
+            echo -e "${BOLD}Rolling back to latest checkpoint: $latest_id${NC}"
+            echo ""
+            _rollback_restore "$latest_id" "$want_code"
+            ;;
+        help|--help|-h)
+            echo -e "${BOLD}loki rollback${NC} - One-command rollback to a checkpoint"
+            echo ""
+            echo "Restore .loki/ state and iteration/conversation context to a"
+            echo "previous checkpoint. Every rollback first saves your current state"
+            echo "as a pre-rollback snapshot, so you can always undo the undo."
+            echo ""
+            echo "Usage: loki rollback <command> [args]"
+            echo ""
+            echo "Commands:"
+            echo "  list              List recent checkpoints"
+            echo "  show <id>         Show checkpoint details"
+            echo "  to <id> [--code]  Restore to checkpoint <id>"
+            echo "  latest [--code]   Restore to the most recent checkpoint"
+            echo ""
+            echo "  --code            Also restore the working tree from the anchored"
+            echo "                    git snapshot (tracked files only; overwrites them)."
+            echo ""
+            echo "Examples:"
+            echo "  loki rollback list"
+            echo "  loki rollback latest"
+            echo "  loki rollback to cp-3-1717000000"
+            echo "  loki rollback to cp-3-1717000000 --code"
+            ;;
+        *)
+            echo -e "${RED}Unknown rollback command: $subcommand${NC}"
+            echo "Run 'loki rollback help' for usage."
+            return 1
+            ;;
+    esac
+}
+
 # Completion Council management
 cmd_council() {
     local subcommand="${1:-status}"
@@ -22633,6 +22808,124 @@ run_debate(
     log_info "Debate complete"
 }
 
+# =============================================================================
+# loki wiki -- auto-generated, cited per-project codebase wiki + Q&A (R5).
+#
+# Loki's answer to Devin DeepWiki: a persistent, queryable wiki built from the
+# codebase, where every section cites the real source files it came from, plus
+# a grounded `ask` that returns cited answers (file:line). Heavy work lives in
+# the Python core (autonomy/lib/wiki-generator.py, wiki-ask.py, wiki_index.py);
+# this is a thin dispatcher, mirroring how cmd_proof delegates to the proof
+# generator. Generation is incremental (skips when the codebase is unchanged).
+# =============================================================================
+cmd_wiki() {
+    local subcmd="${1:-}"
+    shift 2>/dev/null || true
+
+    local lib_dir="${_LOKI_SCRIPT_DIR}/lib"
+
+    case "$subcmd" in
+        generate) _wiki_generate "$lib_dir" "$@" ;;
+        show)     _wiki_show "$@" ;;
+        ask)      _wiki_ask "$lib_dir" "$@" ;;
+        --help|-h|help|"")
+            echo -e "${BOLD}loki wiki${NC} - Auto-generated, cited codebase wiki + Q&A"
+            echo ""
+            echo "Usage: loki wiki <command> [options]"
+            echo ""
+            echo "Commands:"
+            echo "  generate [path] [--force]   Build/refresh the cited wiki in .loki/wiki/"
+            echo "  show [section]              Print the wiki (or one section: architecture|modules|data-flow)"
+            echo "  ask \"<question>\"           Cited answer grounded in the codebase (file:line)"
+            echo ""
+            echo "Each wiki section cites the real source files it was built from."
+            echo "Generation is incremental: it skips when the codebase is unchanged."
+            echo ""
+            echo "Examples:"
+            echo "  loki wiki generate                     # build wiki for current project"
+            echo "  loki wiki show architecture            # show one section"
+            echo "  loki wiki ask \"how does the cli dispatch commands\""
+            return 0
+            ;;
+        *)
+            log_error "Unknown wiki command: $subcmd"
+            echo "Run 'loki wiki --help' for usage."
+            return 1
+            ;;
+    esac
+}
+
+_wiki_generate() {
+    local lib_dir="$1"; shift
+    if ! command -v python3 >/dev/null 2>&1; then
+        log_error "python3 is required for 'loki wiki generate'"
+        return 1
+    fi
+    python3 "$lib_dir/wiki-generator.py" "$@"
+}
+
+_wiki_show() {
+    local section=""
+    local target="."
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --help|-h)
+                echo "Usage: loki wiki show [section]"
+                echo "Sections: architecture, modules, data-flow"
+                return 0
+                ;;
+            -*) log_error "Unknown option: $1"; return 1 ;;
+            *) section="$1"; shift ;;
+        esac
+    done
+    local wiki_dir="$target/.loki/wiki"
+    if [ ! -d "$wiki_dir" ]; then
+        log_error "No wiki found. Run 'loki wiki generate' first."
+        return 1
+    fi
+    if [ -n "$section" ]; then
+        local f="$wiki_dir/${section}.md"
+        if [ ! -f "$f" ]; then
+            log_error "No such section: $section (try: architecture, modules, data-flow)"
+            return 1
+        fi
+        cat "$f"
+    else
+        if [ -f "$wiki_dir/index.md" ]; then
+            cat "$wiki_dir/index.md"
+        else
+            log_error "Wiki index not found. Run 'loki wiki generate'."
+            return 1
+        fi
+    fi
+}
+
+_wiki_ask() {
+    local lib_dir="$1"; shift
+    local question=""
+    local extra=()
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --help|-h)
+                echo "Usage: loki wiki ask \"<question>\" [--json] [--k N]"
+                return 0
+                ;;
+            --json|--quiet) extra+=("$1"); shift ;;
+            --k) extra+=("--k" "${2:-6}"); shift 2 ;;
+            *) if [ -z "$question" ]; then question="$1"; else question="$question $1"; fi; shift ;;
+        esac
+    done
+    if [ -z "$question" ]; then
+        log_error "Provide a question: loki wiki ask \"how does X work\""
+        return 1
+    fi
+    if ! command -v python3 >/dev/null 2>&1; then
+        log_error "python3 is required for 'loki wiki ask'"
+        return 1
+    fi
+    python3 "$lib_dir/wiki-ask.py" --question "$question" "${extra[@]}"
+}
+
 cmd_magic() {
     local subcmd="${1:-help}"
     shift 2>/dev/null || true

package/autonomy/run.sh

@@ -7443,10 +7443,18 @@ create_checkpoint() {
 
     mkdir -p "$checkpoint_dir"
 
-    # Only checkpoint if there are uncommitted changes
-    if git diff --quiet 2>/dev/null && git diff --cached --quiet 2>/dev/null; then
-        log_info "No uncommitted changes to checkpoint"
-        return 0
+    # Only checkpoint if there are uncommitted changes.
+    # R6: _LOKI_CP_FORCE=1 bypasses this guard. Used by rollback to guarantee a
+    # pre-rollback snapshot of .loki/ state even when the git tree is clean (the
+    # .loki/ state files about to be overwritten are not git-tracked, so the
+    # clean-tree guard would otherwise skip the safety snapshot). Mirrors the
+    # Bun `forceCreate` seam in checkpoint.ts.
+    if [ "${_LOKI_CP_FORCE:-0}" != "1" ]; then
+        if git diff --quiet 2>/dev/null && git diff --cached --quiet 2>/dev/null; then
+            log_info "No uncommitted changes to checkpoint"
+            _LAST_CHECKPOINT_ID=""
+            return 0
+        fi
     fi
 
     # Capture git state
@@ -7465,7 +7473,9 @@ create_checkpoint() {
 
     # Copy critical state files (lightweight -- not full .loki/)
     # BUG-ST-009: Include autonomy-state.json in checkpoint backup
-    for f in state/orchestrator.json autonomy-state.json queue/pending.json queue/completed.json queue/in-progress.json queue/current-task.json; do
+    # R6: Include CONTINUITY.md so a rollback also restores iteration/conversation
+    # handoff context, not just machine state. Mirrors Bun COPIED_FILES.
+    for f in state/orchestrator.json autonomy-state.json queue/pending.json queue/completed.json queue/in-progress.json queue/current-task.json CONTINUITY.md; do
         if [ -f ".loki/$f" ]; then
             local target_dir="$cp_dir/$(dirname "$f")"
             mkdir -p "$target_dir"
@@ -7473,6 +7483,23 @@ create_checkpoint() {
         fi
     done
 
+    # R6: capture a real working-tree snapshot so code can be truly undone later.
+    # Loki does not commit per iteration, so git_sha (HEAD) cannot reconstruct
+    # this iteration's working tree. `git stash create` builds a commit object
+    # capturing tracked changes WITHOUT disturbing the tree; we then anchor it
+    # under refs/loki/cp/<id> so `git gc` cannot prune the dangling commit. The
+    # snapshot sha goes in a sidecar (worktree-snapshot.txt), NOT metadata.json,
+    # to preserve byte-for-byte parity with the Bun port.
+    # Honest limit: captures tracked changes only (not untracked/ignored files).
+    if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+        local snap_sha
+        snap_sha=$(git stash create "loki checkpoint ${checkpoint_id}" 2>/dev/null || echo "")
+        if [ -n "$snap_sha" ]; then
+            git update-ref "refs/loki/cp/${checkpoint_id}" "$snap_sha" 2>/dev/null \
+                && printf '%s\n' "$snap_sha" > "$cp_dir/worktree-snapshot.txt" 2>/dev/null || true
+        fi
+    fi
+
     # Write checkpoint metadata (use python3 json.dumps for safe serialization)
     local phase_val
     phase_val=$(cat .loki/state/orchestrator.json 2>/dev/null | python3 -c 'import sys,json; print(json.load(sys.stdin).get("currentPhase","unknown"))' 2>/dev/null || echo 'unknown')
@@ -7531,6 +7558,10 @@ print(json.dumps({'id':m['id'],'ts':m['timestamp'],'iter':m['iteration'],'task':
     fi
 
     log_info "Checkpoint created: ${checkpoint_id} (git: ${git_sha:0:8})"
+    # R6: expose the id via a global so callers (rollback, run loop) can reference
+    # it without parsing stdout (log_info writes to stdout, so command-substitution
+    # capture would include log lines).
+    _LAST_CHECKPOINT_ID="$checkpoint_id"
 }
 
 rollback_to_checkpoint() {
@@ -7558,11 +7589,18 @@ rollback_to_checkpoint() {
 
     log_warn "Rolling back to checkpoint: ${checkpoint_id}"
 
-    # Create a pre-rollback checkpoint first
-    create_checkpoint "pre-rollback snapshot" "rollback"
+    # R6 re-undoability invariant: force a pre-rollback snapshot of CURRENT state
+    # before overwriting, even if the git tree is clean (the .loki/ state we are
+    # about to clobber is not git-tracked). _LOKI_CP_FORCE bypasses the clean-tree
+    # guard. Capture the snapshot id so we can tell the user how to undo the undo.
+    _LOKI_CP_FORCE=1 create_checkpoint "pre-rollback snapshot (before restoring ${checkpoint_id})" "rollback"
+    local pre_rollback_id="${_LAST_CHECKPOINT_ID:-}"
+    if [ -n "$pre_rollback_id" ]; then
+        log_info "Saved prior state as ${pre_rollback_id} (undo this rollback with: loki rollback to ${pre_rollback_id})"
+    fi
 
-    # Restore state files
-    for f in state/orchestrator.json queue/pending.json queue/completed.json queue/in-progress.json queue/current-task.json; do
+    # Restore state files (R6: CONTINUITY.md restores iteration/conversation context)
+    for f in state/orchestrator.json queue/pending.json queue/completed.json queue/in-progress.json queue/current-task.json CONTINUITY.md; do
         if [ -f "${cp_dir}/${f}" ]; then
             local target_dir=".loki/$(dirname "$f")"
             mkdir -p "$target_dir"
@@ -7599,9 +7637,17 @@ print(json.dumps({'event':'rollback','checkpoint':os.environ['_RB_CPID'],'git_sh
 
     log_info "State files restored from checkpoint: ${checkpoint_id}"
 
-    if [ -n "$git_sha" ] && [ "$git_sha" != "no-git" ]; then
-        log_info "Git SHA at checkpoint: ${git_sha}"
-        log_info "To rollback code: git reset --hard ${git_sha}"
+    # R6: the prior hint `git reset --hard ${git_sha}` was MISLEADING. git_sha is
+    # HEAD (the last commit), and Loki does not commit per iteration, so a hard
+    # reset would discard the iteration's work rather than reconstruct it. The
+    # correct, durable recovery is the anchored working-tree snapshot, if present.
+    if [ -f "${cp_dir}/worktree-snapshot.txt" ]; then
+        log_info "To also restore the working tree to this checkpoint:"
+        log_info "  git stash apply refs/loki/cp/${checkpoint_id}"
+    elif [ -n "$git_sha" ] && [ "$git_sha" != "no-git" ]; then
+        log_info "Git SHA at checkpoint (last commit): ${git_sha}"
+        log_info "Note: no working-tree snapshot was captured for this checkpoint;"
+        log_info "code changes since the last commit are not restorable from here."
     fi
 }
 
@@ -12001,6 +12047,10 @@ if __name__ == "__main__":
 
         # Checkpoint after each iteration (v5.57.0)
         create_checkpoint "iteration-${ITERATION_COUNT} complete" "iteration-${ITERATION_COUNT}"
+        # R6: prominent "you can safely undo this" signal so users run boldly.
+        if [ -n "${_LAST_CHECKPOINT_ID:-}" ]; then
+            log_info "Safety net: checkpoint ${_LAST_CHECKPOINT_ID} saved. Undo this iteration with: loki rollback to ${_LAST_CHECKPOINT_ID}"
+        fi
 
         # Quality gates (v6.10.0 - escalation ladder)
         log_step "Post-iteration: running quality gates..."

package/bin/loki

@@ -116,7 +116,7 @@ fi
 # Two-token routes (provider show/list, memory list/index) match on the first
 # token only; the Bun dispatcher handles subcommand routing internally.
 case "${1:-}" in
-    version|--version|-v|status|stats|doctor|provider|memory|rollback|internal|kpis|proof)
+    version|--version|-v|status|stats|doctor|provider|memory|rollback|internal|kpis|proof|wiki)
         # v7.5.2: rollback added (wires loki-ts/src/commands/rollback.ts).
         # v7.5.3: internal added for autonomy/run.sh phase1-hooks calls.
         # v7.5.28: kpis added (Phase K MVP: read-only KPI snapshot).

package/dashboard/__init__.py

@@ -7,7 +7,7 @@ Modules:
     control: Session control API (start/stop/pause/resume)
 """
 
-__version__ = "7.12.0"
+__version__ = "7.14.0"
 
 # Expose the control app for easy import
 try: