@jaguilar87/gaia 5.1.0 → 5.1.1

package/bin/cli/context.py

@@ -348,20 +348,29 @@ def _cmd_query(args) -> int:
 
 
 def _cmd_wipe(args) -> int:
-    """Handle `gaia context wipe --workspace W [--yes]`.
+    """Handle `gaia context wipe --workspace W [--yes] [--purge-memory]`.
 
-    Deletes all rows for the workspace (CASCADE removes children).
-    Requires interactive confirmation unless --yes is passed.
+    Deletes the scannable rows for the workspace (CASCADE removes children).
+    scan-v2 SV3: curated memory is PRESERVED across the wipe by default; pass
+    --purge-memory to also destroy it (explicit human curation). Requires
+    interactive confirmation unless --yes is passed.
     """
     workspace = getattr(args, "workspace", None)
     if not workspace:
         print("gaia context wipe: --workspace is required", file=sys.stderr)
         return 2
 
+    purge_memory = getattr(args, "purge_memory", False)
     if not getattr(args, "yes", False):
+        mem_note = (
+            "curated memory WILL ALSO BE DESTROYED"
+            if purge_memory
+            else "curated memory will be PRESERVED"
+        )
         try:
             ans = input(
-                f"gaia context wipe: about to delete ALL rows for workspace {workspace!r}.\n"
+                f"gaia context wipe: about to delete workspace {workspace!r} "
+                f"rows ({mem_note}).\n"
                 f"Type 'yes' to confirm: "
             )
         except EOFError:
@@ -376,13 +385,291 @@ def _cmd_wipe(args) -> int:
         print(f"gaia context wipe: failed to import store: {exc}", file=sys.stderr)
         return 1
 
+    purge_memory = getattr(args, "purge_memory", False)
     try:
-        wipe_workspace(workspace)
+        # scan-v2 SV3 (Vector 4): preserve curated memory across the wipe by
+        # default. --purge-memory is the explicit-human-curation escape hatch
+        # that restores the original full CASCADE (memory destroyed).
+        wipe_workspace(workspace, preserve_memory=not purge_memory)
     except Exception as exc:
         print(f"gaia context wipe: error: {exc}", file=sys.stderr)
         return 1
 
-    print(f"Wiped workspace: {workspace}")
+    if purge_memory:
+        print(f"Wiped workspace (memory PURGED): {workspace}")
+    else:
+        print(f"Wiped workspace (memory preserved): {workspace}")
+    return 0
+
+
+def _cmd_move_project(args) -> int:
+    """Handle ``gaia context move-project --decision D --from-workspace W1
+    --from-name N1 --to-workspace W2 --to-name N2 [--dry-run] [--yes] [--json]``.
+
+    EXECUTES a human-adjudicated scan-v2 move_candidate. `gaia scan` only
+    DETECTS and REPORTS a move (as `move_candidates`); this is the write path
+    that resolves one:
+
+      --decision movido    -> re-key / supersede the OLD projects row to link it
+                              to the successor (writes `superseded_by`, never
+                              hard-deletes). Curated memory / contracts are only
+                              PROPOSED for relocation, not auto-moved -- use
+                              `move-memory` / `move-contracts` for those.
+      --decision duplicado -> structural no-op: both rows are legitimately
+      --decision worktree     independent and are left exactly as they are.
+
+    Named with a leading `move` token so it hyphen-splits to a MUTATIVE_VERB and
+    gates as T3 without any security-layer change (same convention as
+    `move-contracts` / `move-memory`); `--dry-run` downgrades to a preview.
+    """
+    decision = getattr(args, "decision", None)
+    from_ws = getattr(args, "from_workspace", None)
+    from_name = getattr(args, "from_name", None)
+    to_ws = getattr(args, "to_workspace", None)
+    to_name = getattr(args, "to_name", None)
+    dry_run = getattr(args, "dry_run", False)
+    as_json = getattr(args, "json", False)
+
+    if decision not in ("movido", "duplicado", "worktree"):
+        print(
+            "gaia context move-project: --decision must be one of "
+            "movido/duplicado/worktree",
+            file=sys.stderr,
+        )
+        return 2
+    if not all((from_ws, from_name, to_ws, to_name)):
+        print(
+            "gaia context move-project: --from-workspace/--from-name/"
+            "--to-workspace/--to-name are all required",
+            file=sys.stderr,
+        )
+        return 2
+
+    # duplicado / worktree: legitimate independent rows -> structural no-op.
+    if decision in ("duplicado", "worktree"):
+        result = {
+            "status": "noop",
+            "decision": decision,
+            "from": {"workspace": from_ws, "name": from_name},
+            "to": {"workspace": to_ws, "name": to_name},
+            "reason": (
+                f"decision {decision!r}: both rows are legitimately independent "
+                "-- left untouched (no re-key, no supersede)."
+            ),
+        }
+        if as_json:
+            print(json.dumps(result, indent=2, default=str))
+        else:
+            print(f"[{decision}] no-op: left both project rows untouched "
+                  f"({from_ws}/{from_name} and {to_ws}/{to_name}).")
+        return 0
+
+    # movido:
+    try:
+        from gaia.store.writer import resolve_move_candidate
+    except Exception as exc:
+        print(f"gaia context move-project: failed to import store: {exc}", file=sys.stderr)
+        return 1
+
+    try:
+        preview = resolve_move_candidate(
+            from_ws, from_name, to_ws, to_name, dry_run=True,
+        )
+    except ValueError as exc:
+        print(f"gaia context move-project: {exc}", file=sys.stderr)
+        return 1
+
+    if dry_run:
+        if as_json:
+            print(json.dumps(preview, indent=2, default=str))
+        else:
+            print(f"[dry-run] move-project (movido) {from_ws}/{from_name} -> "
+                  f"{to_ws}/{to_name}:")
+            print(f"  action        : {preview['action']}")
+            print(f"  superseded_by : {preview['superseded_by']}")
+            rel = preview["proposed_relocations"]
+            print(f"  proposed relocations (NOT auto-moved): "
+                  f"memory={rel['memory']} contracts={rel['contracts']}")
+            print("  -> relocate collateral with `gaia context move-memory` / "
+                  "`move-contracts` if desired.")
+        return 0
+
+    if not getattr(args, "yes", False):
+        print(f"About to resolve move (movido): re-key/supersede "
+              f"{from_ws}/{from_name} -> {to_ws}/{to_name} "
+              f"(action={preview['action']}, no hard-delete).")
+        try:
+            ans = input("Type 'yes' to confirm: ")
+        except EOFError:
+            ans = ""
+        if ans.strip().lower() != "yes":
+            print("Aborted (no confirmation).")
+            return 1
+
+    try:
+        result = resolve_move_candidate(from_ws, from_name, to_ws, to_name)
+    except ValueError as exc:
+        print(f"gaia context move-project: {exc}", file=sys.stderr)
+        return 1
+
+    if as_json:
+        print(json.dumps(result, indent=2, default=str))
+    else:
+        rel = result["proposed_relocations"]
+        print(f"Resolved move (movido): {from_ws}/{from_name} -> {to_ws}/{to_name} "
+              f"(action={result['action']}, superseded_by={result['superseded_by']}).")
+        print(f"Proposed (NOT moved): memory={rel['memory']} contracts={rel['contracts']} "
+              f"still keyed to {from_ws!r} -- relocate with move-memory/move-contracts.")
+    return 0
+
+
+def _cmd_move_contracts(args) -> int:
+    """Handle ``gaia context move-contracts --from W1 --to W2 --contract C ...``.
+
+    Re-keys project_context_contracts rows between workspaces (the only
+    correction path for a mis-keyed contract, since `gaia scan` never touches
+    that table). At least one --contract is required.
+    """
+    from_ws = getattr(args, "from_workspace", None)
+    to_ws = getattr(args, "to_workspace", None)
+    contracts = getattr(args, "contract", None) or []
+    on_conflict = getattr(args, "on_conflict", "error")
+    dry_run = getattr(args, "dry_run", False)
+    as_json = getattr(args, "json", False)
+
+    if not from_ws or not to_ws:
+        print("gaia context move-contracts: --from and --to are required", file=sys.stderr)
+        return 2
+    if not contracts:
+        print("gaia context move-contracts: at least one --contract is required", file=sys.stderr)
+        return 2
+
+    try:
+        from gaia.store.writer import relocate_contracts
+    except Exception as exc:
+        print(f"gaia context move-contracts: failed to import store: {exc}", file=sys.stderr)
+        return 1
+
+    try:
+        preview = relocate_contracts(
+            from_ws, to_ws, contracts, on_conflict=on_conflict, dry_run=True
+        )
+    except ValueError as exc:
+        print(f"gaia context move-contracts: {exc}", file=sys.stderr)
+        return 1
+
+    if dry_run:
+        if as_json:
+            print(json.dumps(preview, indent=2, default=str))
+        else:
+            print(f"[dry-run] move-contracts {from_ws!r} -> {to_ws!r}:")
+            print(f"  would move : {preview['moved']}")
+            print(f"  skipped    : {preview['skipped']}")
+            print(f"  missing    : {preview['missing']}")
+            print(f"  overwritten: {preview['overwritten']}")
+        return 0
+
+    if not getattr(args, "yes", False):
+        print(f"About to move {len(preview['moved'])} contract(s) from {from_ws!r} to {to_ws!r}: {preview['moved']}")
+        try:
+            ans = input("Type 'yes' to confirm: ")
+        except EOFError:
+            ans = ""
+        if ans.strip().lower() != "yes":
+            print("Aborted (no confirmation).")
+            return 1
+
+    try:
+        result = relocate_contracts(from_ws, to_ws, contracts, on_conflict=on_conflict)
+    except ValueError as exc:
+        print(f"gaia context move-contracts: {exc}", file=sys.stderr)
+        return 1
+
+    if as_json:
+        print(json.dumps(result, indent=2, default=str))
+    else:
+        print(f"Moved contracts {from_ws!r} -> {to_ws!r}: moved={result['moved']} "
+              f"skipped={result['skipped']} missing={result['missing']} "
+              f"overwritten={result['overwritten']}")
+    return 0
+
+
+def _cmd_move_memory(args) -> int:
+    """Handle ``gaia context move-memory --from W1 --to W2 --name N ...``.
+
+    Re-keys curated `memory` rows (and their intra-set memory_links) between
+    workspaces -- the only correction path for a mis-keyed memory note, since
+    `gaia scan` never touches that table. Subject to the curated-memory write
+    guard: run from a human shell or the orchestrator/operator context (a
+    non-curator subagent dispatch is refused). At least one --name is required.
+    """
+    from_ws = getattr(args, "from_workspace", None)
+    to_ws = getattr(args, "to_workspace", None)
+    names = getattr(args, "name", None) or []
+    on_conflict = getattr(args, "on_conflict", "error")
+    dry_run = getattr(args, "dry_run", False)
+    as_json = getattr(args, "json", False)
+
+    if not from_ws or not to_ws:
+        print("gaia context move-memory: --from and --to are required", file=sys.stderr)
+        return 2
+    if not names:
+        print("gaia context move-memory: at least one --name is required", file=sys.stderr)
+        return 2
+
+    try:
+        from gaia.store.writer import relocate_memory, MemoryWriteForbidden
+    except Exception as exc:
+        print(f"gaia context move-memory: failed to import store: {exc}", file=sys.stderr)
+        return 1
+
+    try:
+        preview = relocate_memory(
+            from_ws, to_ws, names, on_conflict=on_conflict, dry_run=True
+        )
+    except MemoryWriteForbidden as exc:
+        print(f"gaia context move-memory: {exc}", file=sys.stderr)
+        return 1
+    except ValueError as exc:
+        print(f"gaia context move-memory: {exc}", file=sys.stderr)
+        return 1
+
+    if dry_run:
+        if as_json:
+            print(json.dumps(preview, indent=2, default=str))
+        else:
+            print(f"[dry-run] move-memory {from_ws!r} -> {to_ws!r}:")
+            print(f"  would move   : {preview['moved']}")
+            print(f"  skipped      : {preview['skipped']}")
+            print(f"  missing      : {preview['missing']}")
+            print(f"  overwritten  : {preview['overwritten']}")
+            print(f"  links_moved  : {preview['links_moved']}")
+            print(f"  partial_links: {preview['partial_links']}")
+        return 0
+
+    if not getattr(args, "yes", False):
+        print(f"About to move {len(preview['moved'])} memory row(s) from {from_ws!r} to {to_ws!r}: {preview['moved']}")
+        try:
+            ans = input("Type 'yes' to confirm: ")
+        except EOFError:
+            ans = ""
+        if ans.strip().lower() != "yes":
+            print("Aborted (no confirmation).")
+            return 1
+
+    try:
+        result = relocate_memory(from_ws, to_ws, names, on_conflict=on_conflict)
+    except (MemoryWriteForbidden, ValueError) as exc:
+        print(f"gaia context move-memory: {exc}", file=sys.stderr)
+        return 1
+
+    if as_json:
+        print(json.dumps(result, indent=2, default=str))
+    else:
+        print(f"Moved memory {from_ws!r} -> {to_ws!r}: moved={result['moved']} "
+              f"skipped={result['skipped']} missing={result['missing']} "
+              f"overwritten={result['overwritten']} links_moved={result['links_moved']} "
+              f"partial_links={result['partial_links']}")
     return 0
 
 
@@ -500,6 +787,86 @@ def register(subparsers) -> None:
         default=False,
         help="Skip interactive confirmation",
     )
+    wipe_parser.add_argument(
+        "--purge-memory",
+        action="store_true",
+        default=False,
+        help="Also destroy curated memory (default: memory is preserved across "
+             "the wipe). Explicit human curation only.",
+    )
+
+    # gaia context move-contracts --from W1 --to W2 --contract C ...
+    # (T3: the verb token 'move-contracts' hyphen-splits to 'move', which is in
+    # MUTATIVE_VERBS -- gated as T3 without touching the security layer.)
+    mv_parser = ctx_subparsers.add_parser(
+        "move-contracts",
+        help="Re-key project_context_contracts rows between workspaces",
+    )
+    mv_parser.add_argument("--from", dest="from_workspace", metavar="W1", required=True,
+                           help="Source workspace (current, wrong key)")
+    mv_parser.add_argument("--to", dest="to_workspace", metavar="W2", required=True,
+                           help="Destination workspace (correct key)")
+    mv_parser.add_argument("--contract", metavar="C", action="append", default=None,
+                           help="Contract name to move (repeatable)")
+    mv_parser.add_argument("--on-conflict", dest="on_conflict", default="error",
+                           choices=("error", "skip", "overwrite"),
+                           help="Behavior when target already has the contract")
+    mv_parser.add_argument("--dry-run", action="store_true", default=False,
+                           help="Preview the move without mutating")
+    mv_parser.add_argument("--json", action="store_true", default=False,
+                           help="Emit JSON")
+    mv_parser.add_argument("--yes", action="store_true", default=False,
+                           help="Skip interactive confirmation")
+
+    # gaia context move-memory --from W1 --to W2 --name N ...
+    # (T3: the verb token 'move-memory' hyphen-splits to 'move', which is in
+    # MUTATIVE_VERBS -- gated as T3 without touching the security layer.)
+    mm_parser = ctx_subparsers.add_parser(
+        "move-memory",
+        help="Re-key curated `memory` rows (and intra-set links) between workspaces",
+    )
+    mm_parser.add_argument("--from", dest="from_workspace", metavar="W1", required=True,
+                           help="Source workspace (current, wrong key)")
+    mm_parser.add_argument("--to", dest="to_workspace", metavar="W2", required=True,
+                           help="Destination workspace (correct key)")
+    mm_parser.add_argument("--name", metavar="N", action="append", default=None,
+                           help="Memory row name to move (repeatable)")
+    mm_parser.add_argument("--on-conflict", dest="on_conflict", default="error",
+                           choices=("error", "skip", "overwrite"),
+                           help="Behavior when target already has the memory row")
+    mm_parser.add_argument("--dry-run", action="store_true", default=False,
+                           help="Preview the move without mutating")
+    mm_parser.add_argument("--json", action="store_true", default=False,
+                           help="Emit JSON")
+    mm_parser.add_argument("--yes", action="store_true", default=False,
+                           help="Skip interactive confirmation")
+
+    # gaia context move-project --decision D --from-workspace/--from-name
+    #                           --to-workspace/--to-name
+    # (T3: the verb token 'move-project' hyphen-splits to 'move', which is in
+    # MUTATIVE_VERBS -- gated as T3 without touching the security layer. This is
+    # the write path that EXECUTES a scan-v2 move_candidate a human adjudicated.)
+    mp_parser = ctx_subparsers.add_parser(
+        "move-project",
+        help="Resolve an adjudicated scan-v2 move_candidate (re-key/supersede a projects row)",
+    )
+    mp_parser.add_argument("--decision", required=True,
+                           choices=("movido", "duplicado", "worktree"),
+                           help="Human adjudication of the move_candidate")
+    mp_parser.add_argument("--from-workspace", dest="from_workspace", metavar="W1", required=True,
+                           help="Old row workspace (move_candidate from.workspace)")
+    mp_parser.add_argument("--from-name", dest="from_name", metavar="N1", required=True,
+                           help="Old row name (move_candidate from.project)")
+    mp_parser.add_argument("--to-workspace", dest="to_workspace", metavar="W2", required=True,
+                           help="Successor workspace (move_candidate to.workspace)")
+    mp_parser.add_argument("--to-name", dest="to_name", metavar="N2", required=True,
+                           help="Successor name (move_candidate to.project)")
+    mp_parser.add_argument("--dry-run", action="store_true", default=False,
+                           help="Preview the resolution without mutating")
+    mp_parser.add_argument("--json", action="store_true", default=False,
+                           help="Emit JSON")
+    mp_parser.add_argument("--yes", action="store_true", default=False,
+                           help="Skip interactive confirmation")
 
 
 def cmd_context(args) -> int:
@@ -517,6 +884,12 @@ def cmd_context(args) -> int:
         return _cmd_query(args)
     if context_cmd == "wipe":
         return _cmd_wipe(args)
+    if context_cmd == "move-contracts":
+        return _cmd_move_contracts(args)
+    if context_cmd == "move-memory":
+        return _cmd_move_memory(args)
+    if context_cmd == "move-project":
+        return _cmd_move_project(args)
 
     # No sub-action: print help for the context subcommand
     import argparse

package/bin/cli/doctor.py

@@ -206,7 +206,7 @@ def _package_root() -> Path:
 # in lock-step with the INSERT it adds to bootstrap_database.sh. If a user
 # upgrades the CLI past a schema bump but does not re-run `gaia install`,
 # `check_schema_version` raises a warning telling them how to repair.
-EXPECTED_SCHEMA_VERSION = 21
+EXPECTED_SCHEMA_VERSION = 26
 
 # Locations the doctor reads outside the workspace.
 _INSTALL_ERROR_MARKER = Path("~/.gaia/last-install-error.json").expanduser()

package/bin/cli/history.py

@@ -13,6 +13,7 @@ Flags:
   --blocked / -b       Show only BLOCKED or NEEDS_INPUT sessions
   --agent / -a NAME    Filter by agent name
   --limit / -n N       Max sessions to show (default 20)
+  --workspace NAME     Workspace identity override (default: gaia.project.current())
   --json               Machine-readable output
 """
 
@@ -48,7 +49,7 @@ def _find_project_root() -> Path:
 # Data readers
 # ---------------------------------------------------------------------------
 
-def _read_workflow_metrics(root: Path) -> list:
+def _read_workflow_metrics(root: Path, workspace_override: str = None) -> list:
     """
     Read agent session history from gaia.db episodes table.
 
@@ -56,6 +57,9 @@ def _read_workflow_metrics(root: Path) -> list:
     The legacy episodic-memory/index.json and workflow-episodic-memory/metrics.jsonl
     files are no longer read here.
 
+    ``workspace_override`` -- explicit ``--workspace`` value from the CLI.
+    When set, it wins over ``gaia.project.current()`` resolution.
+
     Returns a list of episode dicts (rows with an 'agent' field).
     """
     import sys as _sys
@@ -71,10 +75,13 @@ def _read_workflow_metrics(root: Path) -> list:
     except ImportError:
         return []
 
-    try:
-        ws = _project_current(cwd=root)
-    except Exception:
-        ws = None
+    if workspace_override:
+        ws = workspace_override
+    else:
+        try:
+            ws = _project_current(cwd=root)
+        except Exception:
+            ws = None
 
     try:
         con = _store_connect()
@@ -199,6 +206,10 @@ def register(subparsers):
         metavar="N",
         help="Maximum number of sessions to show (default: 20)",
     )
+    p.add_argument(
+        "--workspace", default=None,
+        help="Workspace identity override. Default: gaia.project.current().",
+    )
     p.add_argument(
         "--json",
         action="store_true",
@@ -213,6 +224,7 @@ def cmd_history(args) -> int:
     root = _find_project_root()
     claude_dir = root / ".claude"
     as_json = getattr(args, "json", False)
+    workspace_override = getattr(args, "workspace", None)
 
     if not claude_dir.exists():
         if as_json:
@@ -222,7 +234,7 @@ def cmd_history(args) -> int:
             print("  Run: gaia scan\n")
         return 1
 
-    entries = _read_workflow_metrics(root)
+    entries = _read_workflow_metrics(root, workspace_override)
 
     if not entries:
         if as_json:

package/bin/cli/install.py

@@ -295,7 +295,7 @@ def _run_bootstrap(db_path: str | None, verbose: bool, quiet: bool) -> dict:
 
     env = os.environ.copy()
     if db_path:
-        env["GAIA_DB"] = str(Path(db_path).expanduser())
+        env["GAIA_DB"] = str(Path(db_path).expanduser().resolve())
 
     cmd = ["bash", str(_BOOTSTRAP_SCRIPT)]
 
@@ -355,7 +355,9 @@ def _seed_contract_permissions(db_path: str | None, quiet: bool) -> dict:
 
     env = os.environ.copy()
     resolved_db = (
-        str(Path(db_path).expanduser()) if db_path else str(Path("~/.gaia/gaia.db").expanduser())
+        str(Path(db_path).expanduser().resolve())
+        if db_path
+        else str(Path("~/.gaia/gaia.db").expanduser().resolve())
     )
     cmd = [sys.executable, str(_SEED_CONTRACT_PERMS), "--db-path", resolved_db]