@namewta/speculo 1.0.5 → 1.0.7

package/template/workflows/ops/H-computer-hygiene/tests/test_hygiene.py

@@ -1,486 +0,0 @@
-"""Isolated tests. Never scan/delete the real user's home or execute package tools."""
-import datetime as dt
-import importlib.util
-import json
-import os
-import tempfile
-import time
-import unittest
-from pathlib import Path
-from unittest import mock
-
-SCRIPT = Path(__file__).resolve().parents[1] / "scripts/hygiene.py"
-spec = importlib.util.spec_from_file_location("hygiene", SCRIPT)
-h = importlib.util.module_from_spec(spec)
-spec.loader.exec_module(h)
-
-
-@unittest.skipUnless(os.name == "posix", "POSIX fixture suite; native Windows requires separate acceptance")
-class HygieneTests(unittest.TestCase):
-    def setUp(self):
-        self.temp = tempfile.TemporaryDirectory(prefix="hygiene-test-")
-        self.root = Path(self.temp.name).resolve()
-        self.home = self.root / "home"
-        self.home.mkdir()
-        self.env = {"PATH": str(self.home / "bin"), "HOME": str(self.home)}
-        self.opts = {"seconds_per_tree": 10, "seconds_total": 30}
-
-    def tearDown(self):
-        self.temp.cleanup()  # test fixture only, never a production cleanup operation
-
-    def old(self, path):
-        timestamp = time.time() - 45 * 86400
-        if path.is_dir():
-            for p in sorted(path.rglob("*"), key=lambda x: len(x.parts), reverse=True):
-                if not p.is_symlink():
-                    os.utime(p, (timestamp, timestamp))
-        os.utime(path, (timestamp, timestamp))
-        return path
-
-    def cache(self, kind="npm-content-cache"):
-        path = h.default_cache_allowlist(self.home, "Linux")[kind]
-        child = {"npm-content-cache": "content-v2/aa/payload", "pip-cache": "wheels/aa/payload.whl", "go-build-cache": "aa/payload-a"}[kind]
-        p = path / child
-        p.parent.mkdir(parents=True, exist_ok=True)
-        p.write_bytes(b"fixture data 123\n")
-        return self.old(path)
-
-    def audit(self, options=None, system="Linux"):
-        a = h.Auditor(home=self.home, system=system, environ=self.env,
-                      options={**self.opts, **(options or {})}, label="ISOLATED_TEST_FIXTURE", native_platform_reads=False)
-        return a, *a.run()
-
-    def plan(self, kinds=("npm-content-cache",)):
-        paths = [self.cache(k) for k in kinds]
-        _, report, plan = self.audit()
-        self.assertEqual(len(plan["actions"]), len(kinds))
-        pp = self.root / "plan.json"
-        h.atomic_json(pp, plan, exclusive=True)
-        ap = self.root / "approval.json"
-        approved = h.approve_plan(pp, [a["id"] for a in plan["actions"]], ap, "I_REVIEWED_EACH_ID", home=self.home, system="Linux")
-        return paths, plan, pp, ap, approved["apply_confirmation"]
-
-    def apply(self, pp, ap, token):
-        return h.apply_plan(pp, ap, token, True, home=self.home, system="Linux")
-
-    def restore(self, receipt):
-        preview = h.restore_receipt(receipt, None, home=self.home, system="Linux")
-        return h.restore_receipt(receipt, preview["confirmation"], home=self.home, system="Linux")
-
-    def test_default_does_not_mutate_source(self):
-        p = self.cache()
-        before = {str(x.relative_to(self.home)): x.read_bytes() for x in self.home.rglob("*") if x.is_file()}
-        self.audit()
-        after = {str(x.relative_to(self.home)): x.read_bytes() for x in self.home.rglob("*") if x.is_file()}
-        self.assertEqual(before, after)
-        self.assertTrue(p.exists())
-        self.assertFalse((self.home / ".speculo-hygiene").exists())
-
-    def test_no_sensitive_environment_export(self):
-        self.env.update({"AWS_SECRET_ACCESS_KEY": "secret-marker", "OPENAI_API_KEY": "api-marker"})
-        _, report, _ = self.audit()
-        self.assertNotIn("secret-marker", json.dumps(report))
-        self.assertNotIn("api-marker", json.dumps(report))
-
-    def test_profile_never_exports_line_contents(self):
-        (self.home / ".zshrc").write_text('export JAVA_HOME="/sdk" # secret-marker\nexport TOKEN="private"\n', encoding="utf-8")
-        _, r, _ = self.audit()
-        text = json.dumps(r)
-        self.assertNotIn("secret-marker", text)
-        self.assertNotIn('TOKEN', text)
-        self.assertIn("JAVA_HOME", text)
-
-    def test_npmrc_credentials_not_exported(self):
-        (self.home / ".npmrc").write_text("//registry.example/:_authToken=secret-marker\ncache=" + str(self.home / "custom-cache") + "\n")
-        _, r, _ = self.audit()
-        self.assertNotIn("secret-marker", json.dumps(r))
-        self.assertTrue(any(x["kind"] == "configured-cache" for x in r["storage"]))
-
-    def test_maven_repository_is_protected(self):
-        p = self.home / ".m2/settings.xml"
-        p.parent.mkdir()
-        repo = self.home / "local-only-artifacts"
-        repo.mkdir()
-        p.write_text(f"<settings><localRepository>{repo}</localRepository><servers><server><password>secret-marker</password></server></servers></settings>")
-        _, r, plan = self.audit()
-        self.assertNotIn("secret-marker", json.dumps(r))
-        item = next(x for x in r["storage"] if x["path"] == str(repo))
-        self.assertEqual(item["risk"], "P")
-        self.assertFalse(plan["actions"])
-
-    def test_path_duplicate_and_multiple_candidates(self):
-        for name in ("bin", "bin2"):
-            p = self.home / name / "java"
-            p.parent.mkdir()
-            p.write_text("not executed")
-            p.chmod(0o755)
-        self.env["PATH"] = ":".join(str(self.home / n) for n in ("bin", "bin2", "bin"))
-        _, r, _ = self.audit()
-        self.assertEqual(len(r["environment"]["commands"]["java"]["matches"]), 2)
-        self.assertTrue(any("duplicate_of" in x for x in r["environment"]["path"]))
-
-    def test_empty_path_flagged_not_searched(self):
-        self.env["PATH"] = ":"
-        _, r, _ = self.audit()
-        self.assertTrue(all(x["status"] == "unsafe-empty" for x in r["environment"]["path"]))
-
-    def test_expand_rejects_shell_expressions(self):
-        for value in ("$(touch bad)", "`id`", "/tmp/a;rm", "$UNSET/x", "relative/path"):
-            self.assertIsNone(h.expand_path(value, self.home, self.env))
-        self.assertEqual(h.expand_path("$HOME/cache", self.home, self.env), self.home / "cache")
-
-    def test_invalid_options_rejected(self):
-        for value in ({"delete_all": True}, {"max_entries_total": True}, {"seconds_total": 0}, {"min_age_days": 0}, {"project_roots": "~"}):
-            with self.subTest(value=value), self.assertRaises(h.SafetyError):
-                h.validate_options(value)
-
-    def test_target_root_rejects_home(self):
-        with self.assertRaises(h.SafetyError):
-            h.target_root(self.home, "Linux", self.env, str(self.home))
-
-    def test_same_day_reports_do_not_overwrite(self):
-        first = h.save_audit(h.Auditor(home=self.home, system="Linux", environ=self.env, options=self.opts), self.root / "reports")
-        second = h.save_audit(h.Auditor(home=self.home, system="Linux", environ=self.env, options=self.opts), self.root / "reports")
-        self.assertNotEqual(first["report"], second["report"])
-        self.assertEqual(Path(first["report"]).name, h.now_local().strftime("%Y-%m-%d") + ".md")
-        self.assertNotIn(str(self.home), Path(first["report"]).read_text())
-        self.assertNotIn(str(self.home), Path(first["json"]).read_text())
-        self.assertIn(str(self.home), Path(first["plan"]).read_text())
-
-    @unittest.skipUnless(hasattr(os, "symlink"), "symlink unavailable")
-    def test_symlink_cache_root_blocked(self):
-        target = self.home / "other"
-        (target / "content-v2").mkdir(parents=True)
-        cache = self.home / ".npm/_cacache"
-        cache.parent.mkdir()
-        cache.symlink_to(target, target_is_directory=True)
-        _, r, p = self.audit()
-        self.assertFalse(p["actions"])
-        self.assertEqual(next(x for x in r["storage"] if x["path"] == str(cache))["status"], "blocked")
-
-    def test_symlink_child_blocks_quarantine(self):
-        p = self.cache()
-        (p / "content-v2/link").symlink_to(self.home, target_is_directory=True)
-        self.old(p)
-        _, _, plan = self.audit()
-        self.assertFalse(plan["actions"])
-
-    def test_symlink_ancestor_blocked(self):
-        target = self.root / "linked-npm"
-        (target / "_cacache/content-v2").mkdir(parents=True)
-        (self.home / ".npm").symlink_to(target, target_is_directory=True)
-        _, _, plan = self.audit()
-        self.assertFalse(plan["actions"])
-
-    def test_hardlinks_not_quarantined_and_size_deduped(self):
-        p = self.cache()
-        source = p / "content-v2/aa/payload"
-        os.link(source, p / "content-v2/aa/payload2")
-        self.old(p)
-        _, r, plan = self.audit()
-        self.assertFalse(plan["actions"])
-        self.assertEqual(r["summary"]["observed_unique_logical_bytes"], source.stat().st_size)
-
-    def test_unknown_cache_structure_not_quarantined(self):
-        p = self.cache()
-        (p / "important-notes.txt").write_text("unique user data")
-        self.old(p)
-        _, _, plan = self.audit()
-        self.assertFalse(plan["actions"])
-
-    def test_recent_cache_not_quarantined(self):
-        p = self.cache()
-        os.utime(p / "content-v2/aa/payload", None)
-        _, _, plan = self.audit()
-        self.assertFalse(plan["actions"])
-
-    def test_custom_cache_not_quarantined(self):
-        p = self.home / "custom-go-cache/aa"
-        p.mkdir(parents=True)
-        (p / "data").write_text("cache")
-        self.env["GOCACHE"] = str(p.parent)
-        self.old(p.parent)
-        _, _, plan = self.audit()
-        self.assertFalse(plan["actions"])
-
-    def test_explicit_exclusion_blocks_action(self):
-        p = self.cache()
-        _, r, plan = self.audit({"exclude_roots": [str(p)]})
-        self.assertFalse(plan["actions"])
-        self.assertTrue(any(x["status"] == "excluded" for x in r["storage"]))
-
-    def test_tree_budget_reports_partial(self):
-        p = self.cache()
-        tree = h.snapshot(p, h.Budget(h.validate_options({"max_entries_per_tree": 1})))
-        self.assertFalse(tree["complete"])
-        self.assertLessEqual(tree["entries"], 1)
-
-    def test_global_budget_reports_partial(self):
-        self.cache()
-        _, r, p = self.audit({"max_entries_total": 1})
-        self.assertTrue(r["scope"]["global_budget_exhausted"])
-        self.assertFalse(p["actions"])
-
-    def test_protected_directory_not_traversed(self):
-        p = self.home / ".ssh"
-        p.mkdir()
-        (p / "secret").write_text("credential")
-        tree = h.snapshot(p, h.Budget(h.validate_options({})))
-        self.assertFalse(tree["complete"])
-        self.assertEqual(tree["files"], 0)
-
-    def test_no_project_roots_is_explicit_gap(self):
-        _, r, _ = self.audit()
-        self.assertEqual(next(x for x in r["scope"]["coverage"] if x["area"] == "projects")["status"], "not-checked")
-
-    def test_project_version_pin_files_are_preserved(self):
-        p = self.home / "Projects/pinned"
-        p.mkdir(parents=True)
-        (p / ".nvmrc").write_text("20")
-        (p / "rust-toolchain.toml").write_text('[toolchain]\nchannel = "stable"')
-        _, report, plan = self.audit({"project_roots": [str(p.parent)]})
-        self.assertIn(".nvmrc", report["projects"][0]["version_pin_files"])
-        self.assertFalse(plan["actions"])
-        self.assertTrue((p / ".nvmrc").exists())
-
-    def test_repo_in_downloads_is_location_warning_not_deletion(self):
-        p = self.home / "Downloads/source"
-        p.mkdir(parents=True)
-        (p / ".git").mkdir()
-        _, report, plan = self.audit({"project_roots": [str(p.parent)]})
-        self.assertTrue(any(x["category"] == "project-location" for x in report["findings"]))
-        self.assertFalse(plan["actions"])
-
-    def test_project_markers_and_lock_conflict_never_delete(self):
-        p = self.home / "Projects/example"
-        p.mkdir(parents=True)
-        (p / ".git").mkdir()
-        (p / "package.json").write_text('{"packageManager":"pnpm@9.0.0","scripts":{"preinstall":"do-not-run"}}')
-        for name in ("pnpm-lock.yaml", "package-lock.json"):
-            (p / name).write_text("fixture")
-        (p / "node_modules").mkdir()
-        _, r, plan = self.audit({"project_roots": [str(p.parent)]})
-        self.assertTrue(r["projects"])
-        self.assertTrue(any("多个 Node" in f["title"] for f in r["findings"]))
-        self.assertFalse(plan["actions"])
-        self.assertNotIn("do-not-run", json.dumps(r))
-
-    def test_gitfile_worktree_not_called_broken_repo(self):
-        p = self.home / "Projects/worktree"
-        p.mkdir(parents=True)
-        (p / ".git").write_text("gitdir: ../../main/.git/worktrees/feature")
-        _, r, _ = self.audit({"project_roots": [str(p.parent)]})
-        self.assertEqual(r["projects"][0]["git"], "gitfile/worktree-or-submodule")
-
-    def test_downloads_are_manual_only(self):
-        p = self.home / "Downloads/installer.dmg"
-        p.parent.mkdir()
-        p.write_bytes(b"installer")
-        _, r, plan = self.audit()
-        self.assertTrue(r["loose_files"])
-        self.assertFalse(plan["actions"])
-
-    def test_all_three_cache_kinds_eligible(self):
-        _, plan, _, _, _ = self.plan(tuple(h.default_cache_allowlist(self.home, "Linux")))
-        self.assertEqual(len(plan["actions"]), 3)
-
-    def test_approval_requires_exact_ids(self):
-        _, plan, pp, _, _ = self.plan()
-        for ids in ([], ["*"], [plan["actions"][0]["id"]] * 2):
-            with self.assertRaises(h.SafetyError):
-                h.approve_plan(pp, ids, self.root / "new-approval.json", "I_REVIEWED_EACH_ID", home=self.home, system="Linux")
-
-    def test_approval_requires_ack(self):
-        _, plan, pp, _, _ = self.plan()
-        with self.assertRaises(h.SafetyError):
-            h.approve_plan(pp, [plan["actions"][0]["id"]], self.root / "new.json", "yes", home=self.home, system="Linux")
-
-    def test_plan_changed_after_approval_refused(self):
-        paths, plan, pp, ap, token = self.plan()
-        plan["warning"] += " modified"
-        h.atomic_json(pp, plan)
-        with self.assertRaises(h.SafetyError):
-            self.apply(pp, ap, token)
-        self.assertTrue(paths[0].exists())
-
-    def test_expired_plan_refused(self):
-        _, plan, pp, _, _ = self.plan()
-        plan["created_at"] = (h.now_local() - dt.timedelta(days=2)).isoformat()
-        plan["expires_at"] = (h.now_local() - dt.timedelta(days=1)).isoformat()
-        h.atomic_json(pp, plan)
-        with self.assertRaises(h.SafetyError):
-            h.read_plan(pp, self.home, "Linux")
-
-    def test_cross_host_plan_refused(self):
-        _, plan, pp, _, _ = self.plan()
-        plan["host_fingerprint"] = "different-host"
-        h.atomic_json(pp, plan)
-        with self.assertRaises(h.SafetyError):
-            h.read_plan(pp, self.home, "Linux")
-
-    def test_arbitrary_path_refused(self):
-        _, plan, pp, _, _ = self.plan()
-        plan["actions"][0]["path"] = str(self.home / "Documents")
-        h.atomic_json(pp, plan)
-        with self.assertRaises(h.SafetyError):
-            h.read_plan(pp, self.home, "Linux")
-
-    def test_arbitrary_command_field_refused(self):
-        _, plan, pp, _, _ = self.plan()
-        plan["actions"][0]["command"] = "rm -rf user-data"
-        h.atomic_json(pp, plan)
-        with self.assertRaises(h.SafetyError):
-            h.read_plan(pp, self.home, "Linux")
-
-    def test_tools_closed_assertion_required(self):
-        paths, _, pp, ap, token = self.plan()
-        with self.assertRaises(h.SafetyError):
-            h.apply_plan(pp, ap, token, False, home=self.home, system="Linux")
-        self.assertTrue(paths[0].exists())
-
-    def test_metadata_drift_refused_before_move(self):
-        paths, _, pp, ap, token = self.plan()
-        (paths[0] / "content-v2/aa/payload").write_text("changed")
-        with self.assertRaises(h.SafetyError):
-            self.apply(pp, ap, token)
-        self.assertTrue(paths[0].exists())
-
-    def test_successful_quarantine_and_restore(self):
-        paths, _, pp, ap, token = self.plan()
-        result = self.apply(pp, ap, token)
-        self.assertFalse(paths[0].exists())
-        self.assertFalse(result["freed_disk_space"])
-        self.restore(Path(result["receipt"]))
-        self.assertTrue(paths[0].exists())
-        self.assertEqual((paths[0] / "content-v2/aa/payload").read_bytes(), b"fixture data 123\n")
-
-    def test_restore_does_not_overwrite_recreated_cache(self):
-        paths, _, pp, ap, token = self.plan()
-        result = self.apply(pp, ap, token)
-        paths[0].mkdir()
-        (paths[0] / "new-data").write_text("keep")
-        with self.assertRaises(h.SafetyError):
-            self.restore(Path(result["receipt"]))
-        self.assertEqual((paths[0] / "new-data").read_text(), "keep")
-
-    def test_restore_receipt_tampering_refused(self):
-        _, _, pp, ap, token = self.plan()
-        receipt = Path(self.apply(pp, ap, token)["receipt"])
-        value = h.load_json(receipt)
-        value["actions"][0]["destination"] = str(self.home / "Documents")
-        h.atomic_json(receipt, value)
-        with self.assertRaises(h.SafetyError):
-            h.restore_receipt(receipt, None, home=self.home, system="Linux")
-
-    def test_quarantine_root_symlink_refused(self):
-        paths, _, pp, ap, token = self.plan()
-        state = self.home / ".speculo-hygiene"
-        state.mkdir()
-        (state / "quarantine").symlink_to(self.root, target_is_directory=True)
-        with self.assertRaises(h.SafetyError):
-            self.apply(pp, ap, token)
-        self.assertTrue(paths[0].exists())
-
-    def test_existing_operation_lock_refused(self):
-        paths, _, pp, ap, token = self.plan()
-        state = self.home / ".speculo-hygiene"
-        state.mkdir()
-        lock = state / "operation.lock"
-        lock.write_text('{"pid":-1}')
-        with self.assertRaises(h.SafetyError):
-            self.apply(pp, ap, token)
-        self.assertTrue(lock.exists())
-        self.assertTrue(paths[0].exists())
-
-    def test_cross_volume_refused_without_copy_fallback(self):
-        paths, _, pp, ap, token = self.plan()
-        original = Path.stat
-        def altered(path, *args, **kwargs):
-            value = original(path, *args, **kwargs)
-            if "quarantine" in path.parts and path.is_relative_to(self.home / ".speculo-hygiene"):
-                parts = list(value)
-                parts[2] = value.st_dev + 123
-                return os.stat_result(parts)
-            return value
-        with mock.patch.object(Path, "stat", altered), self.assertRaises(h.SafetyError):
-            self.apply(pp, ap, token)
-        self.assertTrue(paths[0].exists())
-
-    def test_write_ahead_recovers_rename_then_exception(self):
-        paths, _, pp, ap, token = self.plan()
-        original = os.rename
-        def crash(src, dst):
-            original(src, dst)
-            raise OSError("simulated interruption after rename")
-        with mock.patch.object(h.os, "rename", side_effect=crash), self.assertRaises(h.SafetyError):
-            self.apply(pp, ap, token)
-        self.assertFalse(paths[0].exists())
-        receipt = next((self.home / ".speculo-hygiene/quarantine").glob("*/receipt.json"))
-        self.restore(receipt)
-        self.assertTrue(paths[0].exists())
-
-    def test_partial_failure_preserves_and_restores_prior_move(self):
-        paths, _, pp, ap, token = self.plan(("npm-content-cache", "pip-cache"))
-        original = os.rename
-        count = 0
-        def fail_second(src, dst):
-            nonlocal count
-            count += 1
-            if count == 2:
-                raise OSError("simulated locked file")
-            return original(src, dst)
-        with mock.patch.object(h.os, "rename", side_effect=fail_second), self.assertRaises(h.SafetyError):
-            self.apply(pp, ap, token)
-        receipt = next((self.home / ".speculo-hygiene/quarantine").glob("*/receipt.json"))
-        value = h.load_json(receipt)
-        self.assertEqual(value["status"], "stopped-on-error")
-        self.assertEqual(sum(p.exists() for p in paths), 1)
-        self.restore(receipt)
-        self.assertTrue(all(p.exists() for p in paths))
-
-    def test_mac_bundle_and_launchd_fixture(self):
-        import plistlib
-        for name in ("Example", "Example Copy"):
-            info = self.home / f"Applications/{name}.app/Contents/Info.plist"
-            info.parent.mkdir(parents=True)
-            info.write_bytes(plistlib.dumps({"CFBundleIdentifier": "test.example", "CFBundleShortVersionString": "1.0"}))
-        agent = self.home / "Library/LaunchAgents/test.example.plist"
-        agent.parent.mkdir(parents=True)
-        agent.write_bytes(plistlib.dumps({"Label": "test.example", "ProgramArguments": ["/missing/tool", "secret-marker"], "EnvironmentVariables": {"TOKEN": "secret-marker"}}))
-        _, r, _ = self.audit(system="Darwin")
-        self.assertEqual(len(r["software"]["applications"]), 2)
-        self.assertNotIn("secret-marker", json.dumps(r))
-        self.assertTrue(any(f["category"] == "software" for f in r["findings"]))
-
-    def test_windows_fixture_does_not_claim_registry_success(self):
-        if os.name == "nt":
-            self.skipTest("This test checks the non-Windows capability gap")
-        _, r, _ = self.audit(system="Windows")
-        self.assertTrue(any("registry unavailable" in x for x in r["software"]["errors"]))
-        self.assertEqual(r["software"]["applications"], [])
-
-    def test_reparse_and_placeholder_flags(self):
-        class FakeStat:
-            st_mode = stat_mode = 0o040700
-            st_file_attributes = h.REPARSE
-        self.assertTrue(h.is_linklike(self.home, FakeStat()))
-        FakeStat.st_file_attributes = h.OFFLINE
-        self.assertTrue(h.is_placeholder(FakeStat()))
-
-    def test_markdown_metadata_cannot_inject_images_or_html(self):
-        rendered = h.cell('![remote](https://example.invalid/track) <script>bad</script>')
-        self.assertNotIn('![', rendered)
-        self.assertNotIn('<script>', rendered)
-        self.assertIn('&lt;script&gt;', rendered)
-
-    def test_report_has_required_sections_and_no_delete_claim(self):
-        _, r, p = self.audit()
-        text = h.render_report(r, p)
-        for heading in ("覆盖范围", "PATH", "配置来源", "工具链", "项目", "软件", "隔离", "回滚", "隐私"):
-            self.assertIn(heading, text)
-        self.assertIn("不释放磁盘空间", text)
-        self.assertIn("未在线访问", text)
-
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)

package/template/workflows/ops/I-intake-and-assess/I-intake-and-assess.md

@@ -1,73 +0,0 @@
----
-id: ops/intake-and-assess
-type: workflow-entry
-workflow: ops
-name: 摄入并评估运维目标
-description: 初始化 Ops，识别全局或项目 scope，创建或恢复 change，并用系统盘点、项目分析和目标身份形成可规划部署档案。
-keywords: [摄入, change, 项目识别, 系统盘点, 部署分析, target profile]
----
-
-# 摄入并评估运维目标
-
-> 激活本 Work 后，先读取 `<Path>{roots.workflows}/ops/README.md</Path>`，再执行本入口。
-
-I 是初始化、scope/project/change 选择、部署模型和 target profile 的唯一 owner。它回答“当前工作属于哪里、目标现在是什么、项目需要怎样部署、现场身份与授权边界是什么、是否已经可以规划”，不构建、安装、启动服务或修改目标。
-
-## 读取范围
-
-1. 先读取 `<Path>{roots.workflows}/ops/README.md</Path>` 与当前 Work 的状态入口。
-2. 再读取 `<Path>{roots.workflows}/ops/common/rules/activation-and-memory.md</Path>`，按当前分支、状态和关键词定位最小相关工件。
-3. 只在本 Work 明确要求恢复、冲突、执行安全或归档证据时扩展为全量读取；缺少匹配证据或 owner/gateway 时停止受影响分支。
-
-
-## 流程
-
-### 1. 初始化与确定 Scope
-
-读取 `<Path>{roots.workflows}/ops/common/rules/project-and-change-scope.md</Path>`。缺少状态时以 schema v2 seed 原子创建 `status.json`，并创建不存在的全局 `changes/`、`archive/`、`context/`、`adr/`、`runbooks/` 和 `projects/`；已有内容只验证，不覆盖或猜测迁移。
-
-系统基线、Docker/宿主机通用配置或跨项目文档使用 `scope=global`。指定项目的部署、修复、扩容、升级和回滚使用 `scope=project`。项目 scope 必须解析或创建 `<Path>{roots.state}/ops/projects/{project_id}/project.json</Path>`，对照 `<Path>{roots.workflows}/ops/common/schemas/project.schema.json</Path>` 验证稳定 id、显示名、aliases 和无凭据 identity。
-
-### 2. 创建或恢复 Change
-
-在 scope 根选择用户指定 change、唯一 active change 或新 change；多个候选一次性消歧。新 change 使用 `YYYY-MM-DD-<topic>[-NN]`：project scope 从 `<Path>{roots.workflows}/ops/I-intake-and-assess/change-status-template.json</Path>` 创建 `.status.json`，global scope 从 `<Path>{roots.workflows}/ops/I-intake-and-assess/global-change-status-template.json</Path>` 创建；随后用 `<Path>{roots.workflows}/ops/I-intake-and-assess/request-template.md</Path>` 初始化 request、LOG、CONTEXT 和 ADR。
-
-先原子写 change，再将 `{scope, project_id, change}` 加入全局 active。归档历史只读；继续历史时创建 follow-up，并记录 `derived_from` 的完整 scope locator。项目 change 根必须是 `<Path>{roots.state}/ops/projects/{project_id}/changes/{change}/</Path>`，不得使用全局 flat change 目录。
-
-### 3. 盘点目标系统
-
-读取 `<Path>{roots.workflows}/ops/common/rules/path-and-scope-contract.md</Path>` 和 `<Path>{roots.workflows}/ops/common/rules/evidence-and-redaction.md</Path>`，按 `<Path>{roots.workflows}/ops/I-intake-and-assess/collector-catalog.md</Path>` 运行适用 L0/L1 collectors。L2 只针对用户一次批准的根列表。
-
-把不可覆盖快照写入 change `inventory/snapshots/{snapshot-id}.json`，并从 `<Path>{roots.workflows}/ops/I-intake-and-assess/system-report-template.md</Path>` 更新 `inventory/system-report.md`。瞬时 Docker/进程/端口状态只留在 change；稳定系统事实在 A 阶段才可提升为全局 context。
-
-### 4. 分析项目部署与目标身份
-
-global inventory-only 请求跳过 deployment model，但仍为 verification-only 目标生成非 mutation target profile；global 配置变更则以 `project=null` 建立系统配置 deployment model。project scope 读取真实项目指令和 `<Path>{roots.workflows}/ops/I-intake-and-assess/project-detection.md</Path>`，穷尽实际 manifest、lockfile、容器、CI/CD、配置、服务、集群、数据、健康和恢复线索；结构化格式使用 parser。
-
-读取 `<Path>{roots.workflows}/ops/common/rules/target-profile-and-release-gates.md</Path>`，从 `<Path>{roots.workflows}/ops/I-intake-and-assess/target-profile-template.json</Path>` 生成 `deployment/target-profile.json` v1，并按 `<Path>{roots.workflows}/ops/common/schemas/target-profile.schema.json</Path>` 验证。profile 选择 `audit | takeover | fresh | release | upgrade | rollback`，记录 environment class、唯一 deployment root、existing state、不可拆分 identity assertions、owned/protected/unknown targets、差异分类和 secret provider/locator 元数据。
-
-只要存在持久目录、控制面资源、数据、路由或服务，就使用 takeover；现场为 present 或 unknown 时不得选择 fresh。fresh 只在目标为空、归属明确且 protected/unknown targets 为空时 Ready。mutation 模式必须有整体 identity confirmation；ownership-conflict、unknown difference、未确认身份或不明 deployment root 都使 profile blocked。
-
-会联网、执行项目代码、写 cache 或下载依赖的动态 probe 只登记，不在 I 执行。写入 `deployment/deployment-model.json`、`deployment/target-profile.json` 和 `deployment/deployment-dossier.md`，分别对照 schema 与 `<Path>{roots.workflows}/ops/I-intake-and-assess/deployment-dossier-template.md</Path>`。配置和 secret requirement 只记录 key、scope、provider/受控 source ref、version/presence，不保存值。
-
-### 5. 验证与路由
-
-运行 validator 并重读工件。全局 inventory-only 在快照完整且 audit profile 有效时将 phase 设为 assessment，路由 `<Path>{roots.workflows}/ops/E-execute-and-stabilize/E-execute-and-stabilize.md</Path>` 的 verification-only 分支。项目部署或全局 mutation 只有 deployment model 与 target profile 都 Ready 才进入 `<Path>{roots.workflows}/ops/P-plan-and-approve/P-plan-and-approve.md</Path>`；blocking unknown 保持 blocked，并一次列出 owner 和所需决定。
-
-## 完成标准
-
-- scope/project/change tuple 唯一且与实际目录、全局索引一致；
-- 项目身份不会因目录同名误合并，也不包含凭据；
-- target profile v1 固定 operation mode、environment、deployment root、控制面身份、ownership 与差异分类；
-- present/unknown 现场没有被误判为 fresh，mutation profile 已显式确认整体身份；
-- 适用 collector 全部得到 observed/partial/unavailable/denied/failed 结论；
-- 项目评估穷尽实际部署入口且未把推断伪装为观测；
-- 未发生构建、安装、目标写入或外部 mutation；
-- validator 通过并返回唯一下一路由。
-
-## 子文件引用
-
-- 状态与请求模板：`<Path>{roots.workflows}/ops/I-intake-and-assess/change-status-template.json</Path>`、`<Path>{roots.workflows}/ops/I-intake-and-assess/global-change-status-template.json</Path>`、`<Path>{roots.workflows}/ops/I-intake-and-assess/request-template.md</Path>`
-- 盘点分支：`<Path>{roots.workflows}/ops/I-intake-and-assess/collector-catalog.md</Path>`、`<Path>{roots.workflows}/ops/I-intake-and-assess/system-report-template.md</Path>`
-- 项目分支：`<Path>{roots.workflows}/ops/I-intake-and-assess/project-detection.md</Path>`、`<Path>{roots.workflows}/ops/I-intake-and-assess/deployment-dossier-template.md</Path>`
-- Target profile：`<Path>{roots.workflows}/ops/I-intake-and-assess/target-profile-template.json</Path>`、`<Path>{roots.workflows}/ops/common/schemas/target-profile.schema.json</Path>`

package/template/workflows/ops/I-intake-and-assess/change-status-template.json

@@ -1,26 +0,0 @@
-{
-  "schema_version": 2,
-  "artifact": "ops-change-status",
-  "scope": "project",
-  "project_id": "{project_id}",
-  "change": "{change}",
-  "change_status": "active",
-  "phase": "intake",
-  "current_work": null,
-  "works_run": [],
-  "created_at": "{created_at}",
-  "updated_at": "{updated_at}",
-  "completed_at": null,
-  "archived_at": null,
-  "archive_path": null,
-  "source_revision": null,
-  "target_fingerprint": null,
-  "plan_path": null,
-  "plan_digest": null,
-  "approval_path": null,
-  "approval_status": "not_requested",
-  "approved_batches": [],
-  "latest_attempt_id": null,
-  "outcome": "pending",
-  "blockers": []
-}

package/template/workflows/ops/I-intake-and-assess/collector-catalog.md

@@ -1,28 +0,0 @@
-# 系统盘点 Collector 目录
-
-只选择当前目标适用且已存在的工具。以下命令族是发现候选，不是强制执行清单；运行前检查帮助、版本、权限和输出敏感性。
-
-## L0
-
-| Category | Unix/Linux candidates | macOS candidates | Required result |
-| --- | --- | --- | --- |
-| Host | `uname`, `/etc/os-release`, `hostname`, `uptime` | `uname`, `sw_vers`, `hostname`, `uptime` | OS、架构、稳定目标标识、时间 |
-| Capacity | `nproc`, `free`, `df`, `df -i`, `mount`, `lsblk` | `sysctl`, `vm_stat`, `df`, `mount`, `diskutil` | CPU、内存、挂载点、容量和 inode |
-| Runtimes | 查询已安装 Java/Go/Node/Python/Docker/包管理器版本 | 同左 | executable、版本、来源；不安装 |
-
-## L1
-
-| Category | Candidates | Required result |
-| --- | --- | --- |
-| Services | `systemctl list-units/show`；macOS `launchctl` | 名称、状态、unit/plist、ExecStart、WorkingDirectory |
-| Processes | `ps`、受限 `/proc/<pid>`、`lsof` 或 osquery | PID 仅作瞬时证据；关联 executable、cwd、user |
-| Network | `ss`、`lsof -i`、`netstat` | listener、address、port、process；不扫描外部网络 |
-| Docker | `docker info/ps/compose ls/system df` 和必要 inspect | context、daemon、container/image/volume/network、compose 与 bind path |
-| Kubernetes | current-context 和 scoped `get` | context、namespace、workload、service、ingress；不切换 context |
-| Project locations | 从 service cwd、compose labels、bind mounts 和明确 roots 反查 | 只报告证据支持的路径 |
-
-Docker inspect、Compose config、进程环境和 Kubernetes Secret 可能泄露敏感值。默认不读取进程完整环境或 Secret data，保存前按 evidence-and-redaction 处理。
-
-## L2
-
-只对批准根执行受限深度的容量、权限、文件类型、最大文件或 inode 热点分析。记录根、排除项、超时和实际边界；不得跟随符号链接越界或读取文件正文来判断占用。