claude-dev-env 4.3.0 → 7.1.0

package/.agents/skills/windows-scheduled-task/SKILL.md

@@ -0,0 +1,153 @@
+---
+name: windows-scheduled-task
+description: >-
+  Register a repeating headless Windows scheduled task from PowerShell, with endless repetition, an S4U or Interactive principal, absolute action paths, and a documented teardown. Triggers: register a scheduled task, repeating task, headless task, S4U, Task Scheduler, RepetitionDuration, task will not register, scheduled task access denied, Unregister-ScheduledTask.
+---
+
+# Windows scheduled task
+
+## Contents
+
+- Principle
+- Gotchas
+- When this applies
+- Process
+- Endless repetition
+- Headless principal
+- Absolute paths in the action
+- Settings
+- Placement outside managed paths
+- Status
+- Removal and teardown
+- Self-modification warning
+- Verification
+- Files
+
+## Principle
+
+A registered task carries four decisions. How it repeats, which principal runs it, which absolute
+executable it starts, and where its target files sit. Settle all four at registration time, then
+prove the task by the artifact it changes.
+
+## Gotchas
+
+- `New-ScheduledTaskTrigger -RepetitionDuration ([TimeSpan]::MaxValue)` fails the task XML schema with `The task XML contains a value which is incorrectly formatted or out of range. (10,42):Duration:P99999999DT23H59M59S`.
+- `-LogonType S4U` requires an elevated shell. An unelevated `Register-ScheduledTask` ends with `Access is denied.`
+- Task Scheduler inherits none of the shell PATH. A bare executable name in the action fails at run time.
+- A helper under an installer-managed path deletes itself during an installer run.
+- `LastTaskResult: 0` from a run that took the idle branch says nothing about the branch that acts.
+
+## When this applies
+
+Use this skill for a repeating Windows task registered from PowerShell through the ScheduledTasks
+module. Register the task in an elevated shell when the task must run while the user is signed out.
+
+## Process
+
+1. Resolve every executable in the action with `Get-Command <name>` and read `.Source`.
+2. Read `files[]` in `~/.claude/.claude-dev-env-manifest.json` and pick a directory that list omits.
+3. Build the action with the absolute executable path and `-WindowStyle Hidden` inside the argument string.
+4. Build a `-Once` trigger with a repetition interval and no duration, then clear the duration on the trigger object.
+5. Build the settings set.
+6. Register with an S4U principal, catch the registration failure, and register with an Interactive principal.
+7. Report which principal the registered task holds.
+8. Drive the branch that does the work and read the artifact it changes.
+9. Document the removal command beside the task.
+
+## Endless repetition
+
+```powershell
+$Trigger = New-ScheduledTaskTrigger -Once -At (Get-Date) -RepetitionInterval (New-TimeSpan -Minutes 30)
+$Trigger.Repetition.Duration = ''
+$Trigger.Repetition.StopAtDurationEnd = $false
+```
+
+An empty duration string on the trigger object registers a repetition that keeps firing. Build the
+trigger without a duration argument and set the two properties afterward.
+
+## Headless principal
+
+```powershell
+$Principal = New-ScheduledTaskPrincipal -UserId $env:USERNAME -LogonType S4U
+try {
+    Register-ScheduledTask -TaskName $TaskName -Action $Action -Trigger $Trigger -Settings $Settings -Principal $Principal -Force -ErrorAction Stop
+    $PrincipalKind = 'S4U'
+} catch {
+    $Principal = New-ScheduledTaskPrincipal -UserId $env:USERNAME -LogonType Interactive
+    Register-ScheduledTask -TaskName $TaskName -Action $Action -Trigger $Trigger -Settings $Settings -Principal $Principal -Force
+    $PrincipalKind = 'Interactive'
+}
+```
+
+S4U runs the task with no window whether or not the user is signed in, and its registration needs an
+elevated shell. The Interactive principal with `-WindowStyle Hidden` in the action runs windowless
+while the user is signed in. Report `$PrincipalKind` so the operator knows which one the task holds.
+
+## Absolute paths in the action
+
+```powershell
+$PwshPath = (Get-Command pwsh).Source
+$Action = New-ScheduledTaskAction -Execute $PwshPath -Argument "-NoProfile -WindowStyle Hidden -File ""$ScriptPath"""
+```
+
+Resolve each executable at registration time and store the absolute path in the action. Give the
+script an absolute path too.
+
+## Settings
+
+```powershell
+$Settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable -MultipleInstances IgnoreNew -ExecutionTimeLimit (New-TimeSpan -Hours 1)
+```
+
+These settings keep the task firing on battery power, catch up a missed run, drop an overlapping
+start, and cap a hung run.
+
+## Placement outside managed paths
+
+The claude-dev-env installer records every managed path in `~/.claude/.claude-dev-env-manifest.json`
+under `files[]`, and `--update` removes those paths before it reinstalls from the package. A helper
+that a task starts from a managed directory disappears mid-run. Read `files[]`, then place the
+helper and its state files in a directory the manifest omits, such as a path under `<user home>`
+outside `~/.claude`.
+
+## Status
+
+```powershell
+$Info = Get-ScheduledTaskInfo -TaskName $TaskName
+$Info.LastRunTime
+$Info.LastTaskResult
+$Info.NextRunTime
+```
+
+## Removal and teardown
+
+```powershell
+Unregister-ScheduledTask -TaskName $TaskName -Confirm:$false
+```
+
+Put this command in the same document that describes the task.
+
+## Self-modification warning
+
+A task that installs updates of the agent rules, hooks, and skills rewrites the running session
+instructions on a timer. A major upgrade can land mid-session while the agent holds the older text.
+Give the operator the teardown command, name the interval, and keep the interval wide enough for a
+session to finish between runs.
+
+## Verification
+
+A run that takes the idle branch reports `LastTaskResult: 0`, and that result covers the idle branch
+alone. Prove the acting branch: create the condition the task acts on, wait one interval, then read
+the artifact the task changes and its timestamp.
+
+## Files
+
+- `SKILL.md`. Registration rules, worked examples, status, and teardown.
+
+`packages/claude-dev-env/scripts/Install-SweepEmptyDirs.ps1` is the working model in this repository
+for the install, `-Remove`, and `-Status` parameter sets and symmetric teardown.
+
+```text
+windows-scheduled-task/
+└── SKILL.md
+```

package/_shared/pr-loop/scripts/pr_loop_shared_constants/terminology_sweep_constants.py

@@ -107,6 +107,12 @@ ALL_GIT_DIFF_CACHED_UNIFIED_ZERO_COMMAND: tuple[str, ...] = (
     "--unified=0",
 )
 
+ALL_GIT_DIFF_UNIFIED_ZERO_COMMAND: tuple[str, ...] = (
+    "git",
+    "diff",
+    "--unified=0",
+)
+
 GIT_DIFF_SUBPROCESS_TIMEOUT_SECONDS: int = 30
 
 GIT_NO_MATCH_EXIT_CODE: int = 1

package/_shared/pr-loop/scripts/terminology_sweep.py

@@ -32,6 +32,7 @@ from pr_loop_shared_constants.terminology_sweep_constants import (
     ALL_COMMON_ENGLISH_COMPOUND_TAIL_WORDS,
     ALL_DIFF_FILE_PATH_STRIP_PREFIXES,
     ALL_GIT_DIFF_CACHED_UNIFIED_ZERO_COMMAND,
+    ALL_GIT_DIFF_UNIFIED_ZERO_COMMAND,
     ALL_GIT_GREP_BASE_TREE_COMMAND_PREFIX,
     ALL_PROSE_STOPWORD_TOKENS,
     ALL_STRING_ESCAPE_SEQUENCES,
@@ -622,21 +623,23 @@ def _identifier_names_on_added_code_lines(diff_text: str) -> frozenset[str]:
 
 
 def _base_tree_names(
-    repository_root: Path, all_names: frozenset[str]
+    repository_root: Path,
+    all_names: frozenset[str],
+    tree_revision: str,
 ) -> frozenset[str]:
-    """Return the names the repository's base tree already contains.
+    """Return the names the comparison tree already contains.
 
-    Each name is looked up as a whole word in the base revision's tree. A
-    repository with no commits yet, or a lookup that git cannot run, reports
-    the name as absent, so the sweep then treats it as newly introduced.
-    That is the behaviour the sweep has with no base-tree check at all.
+    Each name is looked up as a whole word in ``tree_revision``. A repository
+    with no commits yet, or a lookup that git cannot run, reports the name as
+    absent, so the sweep treats it as newly introduced.
 
     Args:
         repository_root: The repository root the lookups run in.
         all_names: The identifier names to look up.
+        tree_revision: The revision whose tree is searched.
 
     Returns:
-        The subset of names present in the base tree.
+        The subset of names present in that tree.
     """
     all_present_names: set[str] = set()
     for each_name in sorted(all_names):
@@ -645,7 +648,7 @@ def _base_tree_names(
                 [
                     *ALL_GIT_GREP_BASE_TREE_COMMAND_PREFIX,
                     each_name,
-                    GIT_BASE_TREE_REVISION,
+                    tree_revision,
                 ],
                 cwd=str(repository_root),
                 capture_output=True,
@@ -695,14 +698,16 @@ def _raise_for_git_failure(
 
 
 def _strict_base_tree_names(
-    repository_root: Path, all_names: frozenset[str]
+    repository_root: Path,
+    all_names: frozenset[str],
+    tree_revision: str,
 ) -> frozenset[str]:
     all_present_names: set[str] = set()
     for each_name in sorted(all_names):
         all_arguments = (
             *ALL_GIT_GREP_BASE_TREE_COMMAND_PREFIX,
             each_name,
-            GIT_BASE_TREE_REVISION,
+            tree_revision,
         )
         grep_process = _run_strict_git(repository_root, all_arguments)
         if grep_process.returncode == 0:
@@ -728,14 +733,53 @@ def strict_staged_terminology_findings(repository_root: Path) -> list[str]:
         RuntimeError: Git could not read the staged diff or look up an
             identifier in HEAD.
     """
-    diff_process = _run_strict_git(
-        repository_root, ALL_GIT_DIFF_CACHED_UNIFIED_ZERO_COMMAND
+    return _strict_terminology_findings(
+        repository_root,
+        ALL_GIT_DIFF_CACHED_UNIFIED_ZERO_COMMAND,
+        GIT_BASE_TREE_REVISION,
     )
+
+
+def strict_base_terminology_findings(
+    repository_root: Path, base_revision: str
+) -> list[str]:
+    """Return near-miss findings for worktree changes against a base revision.
+
+    Args:
+        repository_root: The repository root the worktree diff is read from.
+        base_revision: The tree that worktree changes are compared against.
+
+    Returns:
+        One finding string per near-miss term on an added prose line.
+
+    Raises:
+        RuntimeError: Git could not read the committed diff or look up an
+            identifier in the comparison tree.
+    """
+    all_arguments = (
+        *ALL_GIT_DIFF_UNIFIED_ZERO_COMMAND,
+        base_revision,
+    )
+    return _strict_terminology_findings(
+        repository_root,
+        all_arguments,
+        base_revision,
+    )
+
+
+def _strict_terminology_findings(
+    repository_root: Path,
+    all_diff_arguments: Sequence[str],
+    tree_revision: str,
+) -> list[str]:
+    diff_process = _run_strict_git(repository_root, all_diff_arguments)
     _raise_for_git_failure(diff_process, GIT_DIFF_OPERATION)
     all_added_names = _identifier_names_on_added_code_lines(diff_process.stdout)
     preexisting_tuples = frozenset(
         _identifier_token_tuple(each_name)
-        for each_name in _strict_base_tree_names(repository_root, all_added_names)
+        for each_name in _strict_base_tree_names(
+            repository_root, all_added_names, tree_revision
+        )
     )
     return _find_terminology_near_misses(diff_process.stdout, preexisting_tuples)
 
@@ -743,16 +787,15 @@ def strict_staged_terminology_findings(repository_root: Path) -> list[str]:
 def staged_terminology_findings(repository_root: Path) -> list[str]:
     """Return terminology near-miss findings for a repository's staged diff.
 
-    An identifier the base tree already names is not one the staged diff
-    introduces, so no prose is flagged against it. Only genuinely new
-    identifiers are swept.
+    An identifier already present in HEAD is not treated as introduced, so
+    prose is not flagged against it.
 
     Args:
         repository_root: The repository root the staged diff is read from.
 
     Returns:
-        One finding string per near-miss term on a staged added prose line, or
-        an empty list when the staged diff is empty or git cannot be run.
+        One finding string per near-miss term on a staged prose line, or an
+        empty list when the staged diff is empty or git cannot be run.
     """
     diff_process = subprocess.run(
         list(ALL_GIT_DIFF_CACHED_UNIFIED_ZERO_COMMAND),
@@ -770,7 +813,9 @@ def staged_terminology_findings(repository_root: Path) -> list[str]:
     all_added_names = _identifier_names_on_added_code_lines(diff_process.stdout)
     preexisting_tuples = frozenset(
         _identifier_token_tuple(each_name)
-        for each_name in _base_tree_names(repository_root, all_added_names)
+        for each_name in _base_tree_names(
+            repository_root, all_added_names, GIT_BASE_TREE_REVISION
+        )
     )
     return _find_terminology_near_misses(diff_process.stdout, preexisting_tuples)
 

package/_shared/pr-loop/scripts/tests/test_terminology_sweep.py

@@ -31,6 +31,7 @@ sweep_module = _load_sweep_module()
 sweep_diff = sweep_module.sweep_diff
 staged_terminology_findings = sweep_module.staged_terminology_findings
 strict_staged_terminology_findings = sweep_module.strict_staged_terminology_findings
+strict_base_terminology_findings = sweep_module.strict_base_terminology_findings
 main = sweep_module.main
 parse_added_lines = sweep_module._parse_added_lines
 
@@ -53,6 +54,54 @@ def _init_git_repository(repository_path: Path) -> None:
         )
 
 
+def _run_repository_git(repository_path: Path, all_arguments: list[str]) -> str:
+    completed = subprocess.run(
+        all_arguments,
+        cwd=repository_path,
+        check=True,
+        capture_output=True,
+        text=True,
+        env=_hermetic_git_environment(),
+    )
+    return completed.stdout.strip()
+
+
+def _write_repository_text(
+    repository_path: Path, relative_path: str, text: str
+) -> None:
+    (repository_path / relative_path).write_text(text, encoding="utf-8")
+
+
+def _commit_all(repository_path: Path, message: str) -> None:
+    _run_repository_git(repository_path, ["git", "add", "-A"])
+    _run_repository_git(repository_path, ["git", "commit", "-m", message])
+
+
+def _head_revision(repository_path: Path) -> str:
+    return _run_repository_git(repository_path, ["git", "rev-parse", "HEAD"])
+
+
+def _committed_near_miss_repository(repository_path: Path) -> str:
+    _init_git_repository(repository_path)
+    _write_repository_text(repository_path, "quota.py", "baseline = 1\n")
+    _write_repository_text(repository_path, "README.md", "Baseline quota text.\n")
+    _commit_all(repository_path, "base")
+    comparison_revision = _head_revision(repository_path)
+    _write_repository_text(
+        repository_path,
+        "quota.py",
+        "baseline = 1\npremium_request_interactions = 5\n",
+    )
+    _commit_all(repository_path, "identifier")
+    _write_repository_text(
+        repository_path,
+        "README.md",
+        "The premium-request-budget field gates the run.\n",
+    )
+    _commit_all(repository_path, "documentation")
+    return comparison_revision
+
+
 CODE_AND_PROSE_DIFF = (
     "diff --git a/api/quota.py b/api/quota.py\n"
     "--- a/api/quota.py\n"
@@ -310,6 +359,16 @@ def test_staged_terminology_findings_empty_when_clean(tmp_path: Path) -> None:
     assert staged_terminology_findings(tmp_path) == []
 
 
+def test_strict_base_terminology_findings_reports_committed_near_miss(
+    tmp_path: Path,
+) -> None:
+    comparison_revision = _committed_near_miss_repository(tmp_path)
+    all_findings = strict_base_terminology_findings(tmp_path, comparison_revision)
+    assert len(all_findings) == 1
+    assert "README.md:1" in all_findings[0]
+    assert "premium-request-budget" in all_findings[0]
+
+
 def test_parse_added_lines_counts_pre_increment_content_as_added_line() -> None:
     diff_with_pre_increment = (
         "diff --git a/app.mjs b/app.mjs\n"

package/bin/cde.mjs

@@ -6,17 +6,19 @@ import path from "node:path";
 
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const lintScriptPath = path.join(packageRoot, "scripts", "cde_lint.py");
+const verificationScriptPath = path.join(packageRoot, "scripts", "local_verification", "cli.py");
 const posixSignalStatusOffset = 128;
 const lintCommandName = "lint";
+const verifyCommandName = "verify";
 const pythonOptionName = "--python";
 const pythonEnvironmentName = "CDE_PYTHON";
 
 
 export function createHelpText() {
     return [
-        "Usage: cde lint [options]",
+        "Usage: cde <lint|verify> [options]",
         "",
-        "Run the policy linter. Source modes are mutually exclusive:",
+        "Run the policy linter with cde lint. Source modes are mutually exclusive:",
         "  --files PATH [PATH ...]  Current worktree files",
         "  --staged                 Staged index content",
         "  --base REVISION          Changes from a base revision",
@@ -29,6 +31,12 @@ export function createHelpText() {
         "  --python <command>       Python interpreter override",
         "  Exit 0 clean, 1 diagnostics, 2 invalid input or start failure, 3 failed rule",
         "",
+        "Run the required-check manifest with cde verify:",
+        "  --manifest PATH           JSON required-check manifest",
+        "  --repo PATH               Candidate repository root",
+        "  --base SHA                Trusted base revision",
+        "  --output PATH             JSON verification report",
+        "",
         "Python may also be selected with CDE_PYTHON.",
     ].join("\n");
 }
@@ -59,6 +67,14 @@ export function buildLintCommand(interpreter, forwardedArguments) {
 }
 
 
+export function buildVerifyCommand(interpreter, forwardedArguments) {
+    return {
+        executable: interpreter,
+        arguments: [verificationScriptPath, ...forwardedArguments],
+    };
+}
+
+
 function takePythonOverride(allArguments) {
     const remainingArguments = [];
     let interpreterOverride;
@@ -110,7 +126,7 @@ function statusCodeForSignal(signalName) {
 }
 
 
-export function runLintCommand(command, dependencies = {}) {
+function runChildCommand(command, failureMessage, dependencies = {}) {
     const runChild = dependencies.runChild ?? spawn;
     const processEmitter = dependencies.processEmitter ?? process;
     return new Promise((resolve) => {
@@ -122,14 +138,14 @@ export function runLintCommand(command, dependencies = {}) {
                 windowsHide: true,
             });
         } catch {
-            processEmitter.stderr.write("Unable to start the policy linter.\n");
+            processEmitter.stderr.write(`${failureMessage}\n`);
             resolve(2);
             return;
         }
         const detachSignals = attachSignalForwarding(childProcess, processEmitter);
         childProcess.on("error", () => {
             detachSignals();
-            processEmitter.stderr.write("Unable to start the policy linter.\n");
+            processEmitter.stderr.write(`${failureMessage}\n`);
             resolve(2);
         });
         childProcess.on("close", (exitCode, signalName) => {
@@ -144,12 +160,22 @@ export function runLintCommand(command, dependencies = {}) {
 }
 
 
+export function runLintCommand(command, dependencies = {}) {
+    return runChildCommand(command, "Unable to start the policy linter.", dependencies);
+}
+
+
+export function runVerifyCommand(command, dependencies = {}) {
+    return runChildCommand(command, "Unable to start verification.", dependencies);
+}
+
+
 export async function main(argumentsList = process.argv.slice(2), dependencies = {}) {
     if (argumentsList.length === 0 || argumentsList.includes("--help") || argumentsList.includes("-h")) {
         process.stdout.write(`${createHelpText()}\n`);
         return 0;
     }
-    if (argumentsList[0] !== lintCommandName) {
+    if (![lintCommandName, verifyCommandName].includes(argumentsList[0])) {
         process.stderr.write(`${createHelpText()}\n`);
         return 2;
     }
@@ -164,8 +190,10 @@ export async function main(argumentsList = process.argv.slice(2), dependencies =
         process.stderr.write("No usable Python interpreter found. Use --python or CDE_PYTHON.\n");
         return 2;
     }
-    const command = buildLintCommand(interpreter, remainingArguments);
-    const runCommand = dependencies.runCommand ?? runLintCommand;
+    const buildCommand = argumentsList[0] === lintCommandName ? buildLintCommand : buildVerifyCommand;
+    const command = buildCommand(interpreter, remainingArguments);
+    const runCommand = dependencies.runCommand
+        ?? (argumentsList[0] === lintCommandName ? runLintCommand : runVerifyCommand);
     return await runCommand(command, dependencies);
 }
 

package/bin/cde.test.mjs

@@ -7,6 +7,7 @@ import test from "node:test";
 
 import {
     buildLintCommand,
+    buildVerifyCommand,
     createHelpText,
     findPython,
     main,
@@ -43,6 +44,8 @@ test("help describes lint source modes", () => {
     assert.match(helpText, /--base/);
     assert.match(helpText, /--repository/);
     assert.match(helpText, /--text-as/);
+    assert.match(helpText, /cde verify/);
+    assert.match(helpText, /--manifest/);
 });
 
 
@@ -67,6 +70,51 @@ test("forwards lint arguments to the python command without a shell", () => {
 });
 
 
+test("forwards verification arguments to the authoritative python command", () => {
+    const command = buildVerifyCommand("python-test", [
+        "--manifest",
+        "manifest with spaces.json",
+        "--repo",
+        "repo with spaces",
+        "--base",
+        "base-sha",
+        "--output",
+        "report.json",
+    ]);
+    assert.equal(command.executable, "python-test");
+    assert.match(command.arguments[0], /scripts[\\/]local_verification[\\/]cli\.py$/);
+    assert.deepEqual(command.arguments.slice(1), [
+        "--manifest",
+        "manifest with spaces.json",
+        "--repo",
+        "repo with spaces",
+        "--base",
+        "base-sha",
+        "--output",
+        "report.json",
+    ]);
+});
+
+
+test("dispatches verify without changing forwarded arguments", async () => {
+    let receivedCommand;
+    const exitCode = await main(
+        ["verify", "--python", "python-test", "--manifest", "manifest.json"],
+        {
+            findPython: async () => "unused-python",
+            runCommand: async (command) => {
+                receivedCommand = command;
+                return 0;
+            },
+        },
+    );
+    assert.equal(exitCode, 0);
+    assert.equal(receivedCommand.executable, "python-test");
+    assert.match(receivedCommand.arguments[0], /local_verification[\\/]cli\.py$/);
+    assert.deepEqual(receivedCommand.arguments.slice(1), ["--manifest", "manifest.json"]);
+});
+
+
 test("strips the launcher python override from forwarded arguments", async () => {
     let receivedCommand;
     const exitCode = await main(["lint", "--python", "python-test", "--staged"], {

package/bin/ever-shipped-skills.mjs

@@ -1,23 +1,3 @@
-/**
- * The top-level skill directory names this package has ever shipped.
- *
- * The installer subtracts the skills the current package installs from this set
- * to learn which shipped skills have retired, so a full reinstall can remove a
- * retired skill left behind under ~/.agents/skills. Because the current set is
- * subtracted at runtime, restoring a retired skill to the package protects it
- * automatically — it re-enters the installed set and drops out of the retired
- * set on the next install.
- *
- * The list is a committed literal rather than a git query, because a user
- * installs from the npm tarball, which carries no source-repo history. Refresh
- * it by running, from the repository root:
- *
- *   git log --all --pretty=format: --name-only -- \
- *     'packages/claude-dev-env/.agents/skills/*\/SKILL.md' \
- *     'packages/claude-dev-env/skills/*\/SKILL.md' | sort -u
- *
- * and pasting each distinct top-level skill directory name below.
- */
 export const EVER_SHIPPED_SKILL_NAMES = new Set([
     'agent-prompt',
     'anthropic-plan',
@@ -109,6 +89,7 @@ export const EVER_SHIPPED_SKILL_NAMES = new Set([
     'reviewer-gates',
     'reviews',
     'run-claude-dev-env',
+    'session-continuity',
     'session-log',
     'session-tidy',
     'pr-shared-extraction',
@@ -127,4 +108,5 @@ export const EVER_SHIPPED_SKILL_NAMES = new Set([
     'update',
     'usage-pause',
     'verified-build',
+    'windows-scheduled-task',
 ]);

package/bin/ever-shipped-skills.test.mjs

@@ -36,3 +36,11 @@ test('EVER_SHIPPED_SKILL_NAMES retains the explicit test runner', () => {
 test('EVER_SHIPPED_SKILL_NAMES includes the pull request skill', () => {
     assert.equal(EVER_SHIPPED_SKILL_NAMES.has('pull-request'), true);
 });
+
+test('EVER_SHIPPED_SKILL_NAMES includes the windows scheduled task skill', () => {
+    assert.equal(EVER_SHIPPED_SKILL_NAMES.has('windows-scheduled-task'), true);
+});
+
+test('EVER_SHIPPED_SKILL_NAMES includes the session continuity companion', () => {
+    assert.equal(EVER_SHIPPED_SKILL_NAMES.has('session-continuity'), true);
+});

package/bin/expand_home_directory_tokens.mjs

@@ -1,9 +1,8 @@
 /**
- * Install-time expansion of $HOME / ${HOME} / ~/ in settings.json commands.
+ * Expand $HOME, ${HOME}, and ~/ in settings.json commands at install time.
  *
- * Hosts that require referenced env vars at hook load time (for example a third-party host)
- * skip the hook when HOME is unset — common on Windows — so the installer
- * rewrites residual tokens to absolute home paths.
+ * Some hosts skip a hook when HOME is unset, which is common on Windows.
+ * The installer rewrites leftover tokens to absolute home paths.
  */
 
 /**
@@ -34,7 +33,7 @@ export function expandHomeDirectoryTokens(commandString, homeDirectory) {
         () => normalizedHome,
     );
     expandedCommand = expandedCommand.replace(
-        /(^|[\s"'=])~\//g,
+        /(^|[\s"'=;(])~\//g,
         (_fullMatch, boundary) => `${boundary}${normalizedHome}/`,
     );
     return expandedCommand;