gOdoo-cli 1.0.4__tar.gz → 1.0.6__tar.gz

godoo_cli-1.0.6/.agents/skills/godoo-release-management/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: godoo-release-management
+description:
+  Prepare, review, merge, and verify gOdoo releases using the repository's version-bump and publication workflows.
+---
+
+# gOdoo release management
+
+Read `.github/workflows/README.md` and inspect the current release state before acting. Publish or merge only when
+explicitly authorized. Keep the release PR short-lived and coordinate other merges to preserve its intended scope.
+
+Dispatch `.github/workflows/version-bump.yml` against `main` with the selected bump type. The workflow creates
+`release/<version>` and its release PR; leave version changes to it and keep the PR limited to release preparation. Do
+not use long-lived `release` or `develop` branches for this workflow.
+
+The release PR description becomes the release notes. Never replace existing release text or remove its changelog
+summary. If additions are needed, replace the placeholder and preserve the generated changelog and remaining text.
+Review the notes, release-preparation diff, release label, source repository, target branch, title, branch name, package
+version, and available Quality results against the identities in `.github/workflows/README.md` before merging.
+
+After the authorized merge, verify publication to PyPI, the `v<version>` tag at the release merge commit, and the GitHub
+Release. If publication fails, inspect the failed step and existing PyPI, tag, and release state before retrying. Never
+move an existing release tag to repair publication. Report the released version, revision, validation, and any
+downstream adoption required.

{godoo_cli-1.0.4 → godoo_cli-1.0.6}/.agents/skills/godoo-source-workspaces/SKILL.md

@@ -12,7 +12,7 @@ validated before locks or paths and cannot alter host/container depth. Git owns
 archive caches below the shared source root. Never hand-edit managed worktrees or generated `.godoo/` and workspace
 files.
 
-Run `workspace sync` only with authority for the shared source root; it may reset verified managed worktrees.
+Run `workspace sync` only with authority for the shared source root; it updates verified managed worktrees.
 `workspace configure` regenerates state from checked sources. `workspace check` is offline and read-only. Run workspace
 commands from the project directory because that cwd supplies `.env` and manifest-relative paths.
 

{godoo_cli-1.0.4 → godoo_cli-1.0.6}/AGENTS.md

@@ -10,8 +10,8 @@ coherent change.
   detects or orchestrates containers.
 - Load the matching skill under `.agents/skills/` for source-workspace or runtime work; load both only when a change
   crosses those boundaries.
-- Use `godoo-editor-validation` for VS Code diagnostics and development-flow checks, and `godoo-changeset-review` for
-  whole-changeset reviews.
+- Use `godoo-editor-validation` for VS Code diagnostics and development-flow checks, `godoo-changeset-review` for
+  whole-changeset reviews, and `godoo-release-management` for release preparation and publication.
 - Keep shared Docker validation sequential.
 
 ## Branches and releases
@@ -24,13 +24,6 @@ coherent change.
   Follow the existing merge strategy and commit conventions. Push and merge only within explicit authorization.
 - After merge, return to an updated `main` or start the next topic branch from current `origin/main`. Prune stale remote
   references and remove merged branches only after checking ancestry and worktree ownership; preserve unfinished work.
-- Leave package version changes to `.github/workflows/version-bump.yml`, dispatched against `main` with the chosen bump
-  type. It creates `release/<version>` and the release PR; keep that PR limited to preparing the release.
-- Review the release PR description and available Quality results before merging: its description becomes the release
-  notes. The release-labeled PR must target `main` and match the title, branch, and version identities documented in
-  `.github/workflows/README.md`. Publication uses the release merge commit for PyPI, the tag, and the GitHub Release.
-- Keep release PRs short-lived and coordinate other merges to preserve the intended release scope. Do not use a
-  long-lived `release` or `develop` branch for this workflow, or move an existing release tag to repair publication.
 
 ## Code and CLI
 

{godoo_cli-1.0.4 → godoo_cli-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gOdoo-cli
-Version: 1.0.4
+Version: 1.0.6
 Summary: Odoo lifecycle, Python dependency preflight, and shared Git workspaces.
 Project-URL: repository, https://github.com/OpenJKSoftware/gOdoo
 Author-email: Joshua Kreuder <Joshua_Kreuder@outlook.com>

{godoo_cli-1.0.4 → godoo_cli-1.0.6}/docs/hooks.md

@@ -7,18 +7,21 @@ Ordinary restores and major upgrades share the same initialization flow.
 
 ## Choose the right mechanism
 
-| Work                                      | Mechanism                                                         | Runs when                                                           |
-| ----------------------------------------- | ----------------------------------------------------------------- | ------------------------------------------------------------------- |
-| Versioned schema or data repair           | Addon `migrations/<version>/pre-*.py`, `post-*.py`, or `end-*.py` | An eligible installed-to-manifest version change occurs.            |
-| External migration roots                  | Explicit `--upgrade-path`                                         | Selected module updates invoke Odoo's loader.                       |
-| Cursor-based work before registry loading | Explicit `--pre-upgrade-script`                                   | An update selection exists; maps to native `--pre-upgrade-scripts`. |
-| Choose modules to install/update          | `prepare` hook                                                    | Each initialization attempt, before dependency preflight.           |
-| Bootstrap or restore setup                | `after_bootstrap` / `after_restore` hook                          | The matching initialization outcome applies.                        |
-| Recurring environment policy              | `after_reconcile` hook                                            | Reconciliation succeeds and declaration filters match.              |
+| Work                                      | Mechanism                                                         | Mechanism owner | Runs when                                                           |
+| ----------------------------------------- | ----------------------------------------------------------------- | --------------- | ------------------------------------------------------------------- |
+| Versioned schema or data repair           | Addon `migrations/<version>/pre-*.py`, `post-*.py`, or `end-*.py` | Odoo            | An eligible installed-to-manifest version change occurs.            |
+| External migration roots                  | Explicit `--upgrade-path`                                         | Odoo            | Selected module updates invoke Odoo's loader.                       |
+| Cursor-based work before registry loading | Explicit `--pre-upgrade-script`                                   | Odoo            | An update selection exists; maps to native `--pre-upgrade-scripts`. |
+| Choose modules to install/update          | `prepare` hook                                                    | gOdoo           | Each initialization attempt, unless completed with `once=True`.     |
+| Bootstrap or restore setup                | `after_bootstrap` / `after_restore` hook                          | gOdoo           | The matching initialization outcome applies.                        |
+| Recurring environment policy              | `after_reconcile` hook                                            | gOdoo           | Reconciliation succeeds and declaration filters match.              |
+
+Projects supply the migration scripts and hook implementations. gOdoo forwards the selected native migration options to
+Odoo and runs the lifecycle hooks.
 
 Native migration versions must be above the installed version and at or below the manifest version. Fresh installs need
 their own install behavior. There is no transition directory, version-pair selector, implicit module list, or hook
-implicit migration scheduler. Ordinary database hooks can opt into transactional one-shot completion with `once=True`.
+implicit migration scheduler. Hooks can opt into one-shot completion with `once=True`.
 
 ## Discover and select hooks
 
@@ -49,7 +52,7 @@ actual boolean. A missing predicate runs whenever eligible; an exception fails i
 | `phase`        | `prepare`, `after_bootstrap`, `after_restore`, or `after_reconcile`.                                                             |
 | `on`           | Tuple of `ready`, `bootstrapped`, and/or `restored`; defaults to all. Custom outcome filters are invalid for preparation.        |
 | `environments` | Optional tuple of exact `GODOO_ENVIRONMENT` values. Omitted means unrestricted; an allowlist never matches an unset environment. |
-| `once`         | Optional boolean, default false. Record successful database-hook completion; preparation hooks cannot use it.                    |
+| `once`         | Optional boolean, default false. Record successful completion for this hook in the database.                                     |
 
 Environment is a deployment input, never inferred from database contents.
 
@@ -67,10 +70,38 @@ def run(ctx):
     ctx.request_modules(update=["project_base"], install=["helpdesk"])
 ```
 
-Preparation runs without starting Odoo and recomputes requests on every retry. Its context exposes `environment` and
-`request_modules(update=..., install=...)`, with no `env`. Preparation must not mutate databases or external systems. No
-request means no implicit action; even `all` requires an explicit request. Upgrade paths and pre-upgrade scripts remain
-explicit CLI/environment inputs.
+Preparation runs without starting Odoo. Its context exposes `environment` and
+`request_modules(update=..., install=...)`, with no `env`. Pass module names as sequences of strings. Requests combine
+with CLI and environment selections before dependency preflight and native reconciliation.
+
+`install=[...]` in a recurring hook requests installation on each initialization. Modules already installed or queued
+for upgrade are skipped; other requested modules are passed to Odoo for installation. A module uninstalled later is
+requested again on the next initialization. Change or remove the request if that module should remain uninstalled.
+Preparation must not mutate databases or external systems. No request means no implicit action; even `all` requires an
+explicit request. Upgrade paths and pre-upgrade scripts remain explicit CLI/environment inputs.
+
+A one-time preparation hook requests modules until reconciliation succeeds and every requested install is verified:
+
+```python
+# hooks/11_install_feature.py
+from godoo_cli.runtime.hooks import Hook
+
+HOOK = Hook(id="project.install_feature", phase="prepare", once=True)
+
+
+def run(ctx):
+    ctx.request_modules(install=["helpdesk"])
+```
+
+Run `godoo runtime start --hooks-dir /path/to/hooks` to initialize and reconcile before launching Odoo. A standalone
+`runtime launch` only starts a prepared runtime and does not run hooks. Once completed, the hook is skipped even if an
+operator later uninstalls the module. Use a new hook ID for a new installation request. List module names explicitly;
+`install=["all"]` cannot be verified and is rejected in one-time preparation hooks.
+
+One-time preparation runs after bootstrap or restore, when gOdoo can read the database completion record, but before
+other database hooks and native reconciliation. Its dependencies are therefore checked after bootstrap or restore. If
+reconciliation or verification fails, the hook runs again on retry using its current code. Native Odoo work and the
+completion record are separate transactions, so an interruption after native work may cause a retry.
 
 ## Reconcile database state
 
@@ -154,15 +185,17 @@ retries; it is not a completion record.
 
 Use `Hook(id="project.repair.2026_10", phase="after_reconcile", once=True)` for a transactional one-shot repair. IDs are
 immutable: use a new ID for a new repair. The runner stores completion in `ir_config_parameter` under
-`godoo.hooks.once.<identity-hash>`, in the same transaction as the action. Unrestricted hooks complete globally in that
-database; environment-restricted hooks complete separately for each selected environment. Restores and baseline resets
-carry or rewind the records with the database. Declaration filters still apply, and duplicate IDs remain invalid.
-
-Completed hooks skip `needs_run`. A false predicate means the desired state is already satisfied and records completion
-atomically without running the action. An exception rolls back the action and its completion record. A later hook's
-failure preserves earlier committed repairs. Hooks that commit internally or change external systems still need their
-own idempotency: the runner cannot promise exactly-once external effects. Keep recurring environment policy repeatable,
-with state predicates, so ordinary drift is repaired after every controlled start.
+`godoo.hooks.once.<identity-hash>`. For database hooks, it is stored in the same transaction as the action. Unrestricted
+hooks complete globally in that database; environment-restricted hooks complete separately for each selected
+environment. Restores and baseline resets carry or rewind the records with the database. Declaration filters still
+apply, and duplicate IDs remain invalid.
+
+Completed hooks skip `needs_run`. For database hooks, a false predicate records completion atomically without running
+the action; an exception rolls back the action and its completion record. For preparation hooks, completion is recorded
+after successful reconciliation and verification. A later hook's failure preserves earlier committed repairs. Hooks that
+commit internally or change external systems still need their own idempotency: the runner cannot promise exactly-once
+external effects. Keep recurring environment policy repeatable, with state predicates, so ordinary drift is repaired
+after every controlled start.
 
 | Attempt                                        | Outcome visible to hooks                                                            |
 | ---------------------------------------------- | ----------------------------------------------------------------------------------- |

{godoo_cli-1.0.4 → godoo_cli-1.0.6}/docs/workspace.md

@@ -15,7 +15,7 @@ cd /path/to/project
 # Set this in .env instead if each shell should inherit the same value.
 export GODOO_SOURCES_ROOT=/absolute/path/to/shared-sources
 
-# Synchronize managed sources. This can discard edits in verified worktrees.
+# Synchronize managed sources. Tracked edits and untracked path collisions stop synchronization.
 godoo workspace sync
 
 # Generate editor files from the selected sources.
@@ -62,18 +62,19 @@ flowchart TD
     Check --> Build["Production image build copies<br/>selected sources into the image"]
 ```
 
-| Command                 | Changes state? | Purpose                                                                    |
-| ----------------------- | -------------- | -------------------------------------------------------------------------- |
-| `workspace sync`        | Yes            | Update managed worktrees and archive caches; may reset verified worktrees. |
-| `workspace configure`   | Yes            | Validate sources and generate editor files under `.godoo/workspace.lock`.  |
-| `workspace check`       | No             | Validate offline, without source-worktree or archive locks.                |
-| `workspace runtime-env` | No             | Validate sources and emit shell-safe resolved path assignments.            |
-| `workspace materialize` | Yes            | Copy selected sources into an image layout.                                |
-| `workspace storage`     | No             | Inspect shared source storage.                                             |
-| `workspace gc`          | Yes            | Manage shared storage cleanup; inspect `--help` before use.                |
+| Command                 | Changes state? | Purpose                                                                   |
+| ----------------------- | -------------- | ------------------------------------------------------------------------- |
+| `workspace sync`        | Yes            | Update managed worktrees and archive caches; preserve untracked files.    |
+| `workspace configure`   | Yes            | Validate sources and generate editor files under `.godoo/workspace.lock`. |
+| `workspace check`       | No             | Validate offline, without source-worktree or archive locks.               |
+| `workspace runtime-env` | No             | Validate sources and emit shell-safe resolved path assignments.           |
+| `workspace materialize` | Yes            | Copy selected sources into an image layout.                               |
+| `workspace storage`     | No             | Inspect shared source storage.                                            |
+| `workspace gc`          | Yes            | Manage shared storage cleanup; inspect `--help` before use.               |
 
 Git fetches report elapsed time every ten seconds and retain Git output for failure diagnostics. Git owns the pools,
-worktrees, branches, locks, and caches under the shared source root; use workspace commands to manage them.
+worktrees, branches, locks, and caches under the shared source root; use workspace commands to manage them. Tracked
+edits stop synchronization. Untracked and ignored files are preserved; Git rejects updates that would overwrite them.
 
 ## Editor configuration
 

{godoo_cli-1.0.4 → godoo_cli-1.0.6}/src/godoo_cli/__about__.py

@@ -1,3 +1,3 @@
 """Version information."""
 
-__version__ = "1.0.4"
+__version__ = "1.0.6"

{godoo_cli-1.0.4 → godoo_cli-1.0.6}/src/godoo_cli/commands/runtime/init.py

@@ -13,9 +13,21 @@ import typer
 
 from ...models import GodooConfig
 from ...runtime.archive import load_runtime_archive, prepare_archive_with_original_filestore
-from ...runtime.checksums import ModulePlan, module_states, pending_installs, plan_module_changes
+from ...runtime.checksums import (
+    ModulePlan,
+    module_states,
+    pending_installs,
+    plan_module_changes,
+    verify_installed_modules,
+)
 from ...runtime.dataset import resolve_runtime_dataset
-from ...runtime.hooks import discover_hooks, has_eligible_hooks, run_prepare_hooks
+from ...runtime.hooks import (
+    complete_prepare_hooks,
+    discover_hooks,
+    has_eligible_hooks,
+    pending_prepare_hooks,
+    run_prepare_hooks,
+)
 from ...runtime.lifecycle import (
     LifecycleBootstrapError,
     deployment_init,
@@ -423,10 +435,35 @@ def initialize_odoo_runtime(resolve_config: Callable[[], GodooConfig], request:
     plan: ModulePlan | None = None
     selected_updates = split_lifecycle_values(update_modules)
     selected_installs = split_lifecycle_values(install_modules)
+    requested_installs = list(selected_installs)
+    prepare_completion_keys: list[str] = []
 
     def plan_reconciliation(conf: GodooConfig) -> None:
         """Select native work under the lifecycle lock before any database hook."""
-        nonlocal plan, selected_updates, selected_installs
+        nonlocal plan, selected_updates, selected_installs, requested_installs, prepare_completion_keys
+        once_hooks, prepare_completion_keys = pending_prepare_hooks(conf, hooks, environment)
+        if once_hooks:
+            once_modules = run_prepare_hooks(once_hooks, environment, once=True)
+            once_updates = split_lifecycle_values(list(once_modules.update))
+            once_installs = split_lifecycle_values(list(once_modules.install))
+            if "all" in once_installs:
+                message = "One-time preparation hooks must name install modules explicitly; 'all' cannot be verified."
+                raise ValueError(message)
+            selected_updates = list(dict.fromkeys([*selected_updates, *once_updates]))
+            selected_installs = list(dict.fromkeys([*selected_installs, *once_installs]))
+            requested_installs = list(selected_installs)
+            _validate_pre_upgrade_options(
+                runtime_seed is not None or (persisted is not None and persisted["outcome"] == "restored"),
+                pre_upgrade_scripts,
+                selected_updates,
+                has_eligible_hooks(hooks, phase="after_restore", outcome="restored", environment=environment),
+            )
+            preflight_reconcile_dependencies(
+                conf,
+                selected_updates,
+                selected_installs,
+                ignore_missing_installed_modules=bool(pre_upgrade_scripts),
+            )
         if request.update_changed:
             plan = plan_module_changes(
                 conf, selected_updates, selected_installs, pre_upgrade_scripts=bool(pre_upgrade_scripts)
@@ -452,6 +489,10 @@ def initialize_odoo_runtime(resolve_config: Callable[[], GodooConfig], request:
         )
         if result == 0 and plan is not None:
             plan.finish(conf)
+        elif result == 0 and requested_installs:
+            verify_installed_modules(conf, requested_installs)
+        if result == 0:
+            complete_prepare_hooks(conf, prepare_completion_keys)
         return result
 
     try:
@@ -480,7 +521,7 @@ def initialize_odoo_runtime(resolve_config: Callable[[], GodooConfig], request:
     except LifecycleBootstrapError as error:
         LOGGER.exception("Native Odoo bootstrap failed during deployment initialization")
         return error.return_code
-    except (ValueError, RuntimeError, OSError, psycopg2.Error):
+    except (TypeError, ValueError, RuntimeError, OSError, psycopg2.Error):
         LOGGER.exception("Deployment initialization failed")
         return 1
     finally:

{godoo_cli-1.0.4 → godoo_cli-1.0.6}/src/godoo_cli/git/repository.py

@@ -129,22 +129,6 @@ class GitRepository:
         """Return Git common directory for this repository."""
         return Path(self._require_repo().git.rev_parse("--git-common-dir"))
 
-    def switch(self, branch: str, start: str, *, discard_changes: bool = False) -> None:
-        """Switch an existing worktree branch to a commit."""
-        arguments: list[str] = []
-        if discard_changes:
-            arguments.append("--discard-changes")
-        arguments.extend(["-C", branch, start])
-        self._require_repo().git.switch(*arguments)
-
-    def reset_hard(self, commit: str) -> None:
-        """Reset the current worktree to commit."""
-        self._require_repo().git.reset("--hard", commit)
-
-    def clean(self) -> None:
-        """Remove untracked files from the current worktree."""
-        self._require_repo().git.clean("-fdx")
-
 
 def repository(path: Path) -> GitRepository:
     """Open a repository through the shared facade."""

{godoo_cli-1.0.4 → godoo_cli-1.0.6}/src/godoo_cli/runtime/checksums.py

@@ -8,7 +8,7 @@ import logging
 import os
 import re
 from collections.abc import Container, Sequence
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 
 from ..helpers.hashing import fingerprint, sha256_file
@@ -50,6 +50,21 @@ def pending_installs(states: dict[str, ModuleState], requested: list[str]) -> li
     )
 
 
+def verify_installed_modules(config: GodooConfig, requested: list[str]) -> None:
+    """Require every explicitly requested module to be installed after reconciliation."""
+    states = module_states(config)
+    missing = _missing_installs(states, requested)
+    if missing:
+        message = f"Requested modules were not installed: {', '.join(missing)}"
+        raise RuntimeError(message)
+
+
+def _missing_installs(states: dict[str, ModuleState], requested: list[str]) -> list[str]:
+    return sorted(
+        name for name in requested if name != "all" and states.get(name, ModuleState("unknown")).state != "installed"
+    )
+
+
 def _tree_hash(path: Path, *, core: bool = False) -> str:
     files = []
     for directory, folders, names in os.walk(path):
@@ -141,6 +156,7 @@ class ModulePlan:
     updates: list[str]
     installs: list[str]
     snapshot: dict[str, str]
+    requested_installs: list[str] = field(default_factory=list)
 
     def finish(self, config: GodooConfig) -> None:
         """Verify native completion and unchanged sources before saving this snapshot."""
@@ -149,11 +165,7 @@ class ModulePlan:
         if pending:
             message = f"Native reconciliation left unfinished modules: {', '.join(pending)}"
             raise RuntimeError(message)
-        missing_installs = sorted(
-            name
-            for name in self.installs
-            if name != "all" and states.get(name, ModuleState("unknown")).state != "installed"
-        )
+        missing_installs = _missing_installs(states, [*self.installs, *self.requested_installs])
         if missing_installs:
             message = f"Requested modules were not installed: {', '.join(missing_installs)}"
             raise RuntimeError(message)
@@ -217,4 +229,4 @@ def plan_module_changes(
         )
         raise RuntimeError(message)
     LOGGER.info("Source reconciliation selected updates=%s installs=%s", selected_updates, selected_installs)
-    return ModulePlan(selected_updates, selected_installs, snapshot)
+    return ModulePlan(selected_updates, selected_installs, snapshot, requested_installs=list(installs))

{godoo_cli-1.0.4 → godoo_cli-1.0.6}/src/godoo_cli/runtime/hooks.py

@@ -45,9 +45,6 @@ class Hook:
         if type(self.once) is not bool:
             message = "Hook once must be a boolean."
             raise ValueError(message)
-        if self.phase == "prepare" and self.once:
-            message = "Preparation hooks cannot declare once=True."
-            raise ValueError(message)
         if self.phase == "prepare" and self.on != OUTCOMES:
             message = "Preparation hooks cannot filter by outcome."
             raise ValueError(message)
@@ -131,10 +128,14 @@ def has_eligible_hooks(hooks: Iterable[HookDefinition], *, phase: str, outcome:
     return any(_is_eligible(definition.hook, phase, outcome, environment) for definition in hooks)
 
 
-def run_prepare_hooks(hooks: Iterable[HookDefinition], environment: str | None) -> ModuleSelections:
+def run_prepare_hooks(
+    hooks: Iterable[HookDefinition], environment: str | None, *, once: bool = False
+) -> ModuleSelections:
     """Run eligible preparation hooks and collect their module requests."""
     context = _PrepareContext(environment=environment)
     for definition in hooks:
+        if definition.hook.once != once:
+            continue
         if not _is_eligible(definition.hook, "prepare", None, environment):
             LOGGER.info("Hook %s excluded by declaration.", definition.hook.id)
             continue
@@ -142,6 +143,46 @@ def run_prepare_hooks(hooks: Iterable[HookDefinition], environment: str | None)
     return ModuleSelections(update=_deduplicate(context._update), install=_deduplicate(context._install))
 
 
+def _completion_key(hook: Hook, environment: str | None) -> str:
+    scope = environment if hook.environments is not None else None
+    identity = json.dumps([hook.id, scope], separators=(",", ":"))
+    return "godoo.hooks.once." + hashlib.sha256(identity.encode()).hexdigest()
+
+
+def pending_prepare_hooks(
+    config: GodooConfig, hooks: Iterable[HookDefinition], environment: str | None
+) -> tuple[list[HookDefinition], list[str]]:
+    """Select eligible one-time preparation hooks not yet completed in this database."""
+    selected = [
+        definition
+        for definition in hooks
+        if definition.hook.once and _is_eligible(definition.hook, "prepare", None, environment)
+    ]
+    if not selected:
+        return [], []
+    keys = [_completion_key(definition.hook, environment) for definition in selected]
+    with config.db_connection.with_db(config.db_name, readonly=True).connect() as cursor:
+        cursor.execute(
+            "SELECT key FROM ir_config_parameter WHERE key = ANY(%s) AND value IS NOT NULL AND value != ''", [keys]
+        )
+        completed = {row[0] for row in cursor.fetchall()}
+    pending = [(definition, key) for definition, key in zip(selected, keys, strict=True) if key not in completed]
+    return [definition for definition, _key in pending], [key for _definition, key in pending]
+
+
+def complete_prepare_hooks(config: GodooConfig, keys: list[str]) -> None:
+    """Record verified one-time preparation hooks after native reconciliation."""
+    if not keys:
+        return
+    with config.db_connection.connect() as cursor:
+        for key in keys:
+            cursor.execute(
+                "INSERT INTO ir_config_parameter (key, value) VALUES (%s, %s) "
+                "ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value",
+                [key, "1"],
+            )
+
+
 def run_hook_phase(
     config: GodooConfig,
     hooks: Iterable[HookDefinition],
@@ -188,9 +229,7 @@ def _run_database_hook_batch(shell_env: Any, sources: Sequence[str], *, outcome:
                 completion_key = None
                 parameters = None
                 if definition.hook.once:
-                    scope = environment if definition.hook.environments is not None else None
-                    identity = json.dumps([definition.hook.id, scope], separators=(",", ":"))
-                    completion_key = "godoo.hooks.once." + hashlib.sha256(identity.encode()).hexdigest()
+                    completion_key = _completion_key(definition.hook, environment)
                     parameters = context.env["ir.config_parameter"].sudo()
                     if parameters.get_param(completion_key):
                         cursor.rollback()

{godoo_cli-1.0.4 → godoo_cli-1.0.6}/src/godoo_cli/workspace/git.py

@@ -68,7 +68,7 @@ def _status_result(
     cwd: Path | None = None,
     env: dict[str, str] | None = None,
 ) -> tuple[int, str | bytes, str | bytes]:
-    """Run ignored status in porcelain NUL mode for the clean-tree safety check."""
+    """Run status in porcelain NUL mode for worktree safety checks."""
     return native_git_result(*arguments, cwd=cwd, env=env, binary=True)
 
 
@@ -444,36 +444,18 @@ def _head(path: Path) -> str:
     return _repo(path).head_commit()
 
 
-def _assert_clean(path: Path) -> None:
-    """Reject any direct change to a managed worktree."""
+def _assert_clean(path: Path, *, include_untracked: bool = False) -> None:
+    """Reject tracked changes, and all untracked files before removing a worktree."""
+    arguments = ["--untracked-files=all", "--ignored"] if include_untracked else ["--untracked-files=no"]
     returncode, stdout, stderr = _status_result(
-        "--no-optional-locks",
-        "-C",
-        str(path),
-        "status",
-        "--porcelain=v1",
-        "-z",
-        "--untracked-files=all",
-        "--ignored",
+        "--no-optional-locks", "-C", str(path), "status", "--porcelain=v1", "-z", *arguments
     )
     if returncode:
         detail = stderr.strip() or stdout.strip()
         if isinstance(detail, bytes):
             detail = detail.decode(errors="replace")
         workspace_fail(f"Git status failed for {path}: {detail}")
-    entries = os.fsdecode(stdout).split("\0")
-    unexpected = [
-        entry
-        for entry in entries
-        if entry
-        and not (
-            entry.startswith("!! ")
-            and (candidate := path / entry[3:]).name == ".DS_Store"
-            and candidate.is_file()
-            and not candidate.is_symlink()
-        )
-    ]
-    if unexpected:
+    if stdout:
         workspace_fail(f"Managed source is dirty; direct edits are unsupported: {path}")
 
 
@@ -542,6 +524,13 @@ def _checkout_environment() -> dict[str, str]:
     }
 
 
+def _reset_worktree(path: Path, commit: str) -> None:
+    """Restore tracked files without applying host Git configuration."""
+    _worktree_command(
+        "-C", str(path), "-c", "core.autocrlf=false", "reset", "--hard", commit, env=_checkout_environment()
+    )
+
+
 def _merge_commit(path: Path, tree: str, previous: str, commit: str) -> str:
     """Write the deterministic commit used for one ordered merge input."""
     environment = _checkout_environment()
@@ -564,10 +553,47 @@ def _merge_commit(path: Path, tree: str, previous: str, commit: str) -> str:
     )
 
 
+def _assert_no_ignored_merge_collisions(path: Path, commit: str) -> None:
+    """Reject ignored files that an incoming merge could overwrite."""
+
+    def names(*arguments: str) -> set[str]:
+        returncode, stdout, stderr = _status_result("-C", str(path), *arguments, "-z")
+        if returncode:
+            workspace_fail(f"Git path inspection failed for {path}: {os.fsdecode(stderr).strip()}")
+        return set(os.fsdecode(stdout).split("\0")) - {""}
+
+    ignored = names("ls-files", "--others", "--ignored", "--exclude-standard")
+    if not ignored:
+        return
+    tree = _merge_command(
+        "-C",
+        str(path),
+        "-c",
+        "merge.renormalize=false",
+        "-c",
+        "rerere.enabled=false",
+        "merge-tree",
+        "--write-tree",
+        "HEAD",
+        commit,
+        env=_checkout_environment(),
+    ).splitlines()[0]
+    incoming = names("ls-tree", "-r", "--name-only", tree)
+    for name in incoming:
+        parts = name.split("/")
+        if any("/".join(parts[:index]) in ignored for index in range(1, len(parts) + 1)):
+            workspace_fail(f"Ignored file would be overwritten by merge in {path}: {name}")
+    for name in ignored:
+        parts = name.split("/")
+        if any("/".join(parts[:index]) in incoming for index in range(1, len(parts) + 1)):
+            workspace_fail(f"Ignored file would be overwritten by merge in {path}: {name}")
+
+
 def _merge_sources(path: Path, merge_commits: tuple[str, ...]) -> str:
     """Merge ordered inputs using fixed configuration and reproducible commits."""
     environment = _checkout_environment()
     for commit in merge_commits:
+        _assert_no_ignored_merge_collisions(path, commit)
         previous = _head(path)
         _merge_command(
             "-C",
@@ -586,6 +612,7 @@ def _merge_sources(path: Path, merge_commits: tuple[str, ...]) -> str:
             "--no-commit",
             "--no-stat",
             "--no-edit",
+            "--no-overwrite-ignore",
             "--",
             commit,
             env=environment,
@@ -656,7 +683,7 @@ def _publish_worktree(
             occupant = next((item for item in records if Path(item.get("worktree", "")) == path), None)
             if occupant is not None:
                 _usable_worktree(pool, path, root)
-                _assert_clean(path)
+                _assert_clean(path, include_untracked=True)
                 _worktree_command("-C", str(pool), "worktree", "remove", str(path))
             elif path.exists() or path.is_symlink():
                 workspace_fail(f"Readable source worktree path is occupied: {path}")
@@ -668,16 +695,26 @@ def _publish_worktree(
             workspace_fail(
                 f"Managed worktree path is occupied by another branch: {path} ({record.get('branch', 'detached')})."
             )
+        _assert_clean(selected)
         previous = _head(selected)
-        if record.get("branch") != branch_ref:
-            _repo(selected).switch(worktree_branch, base_commit, discard_changes=True)
-        _repo(selected).reset_hard(base_commit)
-        _repo(selected).clean()
+        _worktree_command(
+            "-C",
+            str(selected),
+            "-c",
+            "core.hooksPath=/dev/null",
+            "-c",
+            "core.autocrlf=false",
+            "switch",
+            "--no-overwrite-ignore",
+            "-C",
+            worktree_branch,
+            base_commit,
+            env=_checkout_environment(),
+        )
         try:
             resolved = _merge_sources(selected, merge_commits) if merge_commits else _head(selected)
         except Exception:
-            _repo(selected).reset_hard(previous)
-            _repo(selected).clean()
+            _reset_worktree(selected, previous)
             raise
         return selected, resolved
 
@@ -731,8 +768,7 @@ def _create_worktree(
             )
             created_branch = not existing
             if existing:
-                _repo(staging).reset_hard(base_commit)
-                _repo(staging).clean()
+                _reset_worktree(staging, base_commit)
             resolved = _merge_sources(staging, merge_commits) if merge_commits else _head(staging)
             _assert_clean(staging)
             _worktree_command(