Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
f13118cadf | ||
|
|
11b0ff6750 | ||
|
|
4340fc2a9c | ||
|
|
f1b54f5b0d | ||
|
|
242a5c95c3 | ||
|
|
055a6af7f8 | ||
|
|
a52877e2ae |
@@ -9,7 +9,7 @@
|
||||
"name": "planning-with-files",
|
||||
"source": "./",
|
||||
"description": "Persistent file-based planning for AI coding agents. Crash-proof markdown plans that survive context loss, /clear, and crashes, with an opt-in completion gate and multi-agent shared state on disk. Manus-style, installs across 60+ agents via the SKILL.md standard.",
|
||||
"version": "3.4.1"
|
||||
"version": "3.5.0"
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "planning-with-files",
|
||||
"version": "3.4.1",
|
||||
"version": "3.5.0",
|
||||
"description": "Persistent file-based planning for AI coding agents. Crash-proof markdown plans (task_plan.md, findings.md, progress.md) that survive context loss and /clear, with an opt-in completion gate and multi-agent shared state. Manus-style. Works with Claude Code, Codex CLI, Cursor, Kiro, OpenCode and 60+ agents via the SKILL.md standard. Includes Arabic, German, Spanish, and Chinese (Simplified and Traditional).",
|
||||
"author": {
|
||||
"name": "OthmanAdi",
|
||||
|
||||
@@ -28,7 +28,7 @@ hooks:
|
||||
- type: command
|
||||
command: "RESOLVED=\"\"; SCOPE=\"\"; SLUG_RE='^[A-Za-z0-9_][A-Za-z0-9._-]*$'; if [ -n \"${PLAN_ID:-}\" ] && printf \"%s\" \"$PLAN_ID\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${PLAN_ID}\" ]; then RESOLVED=\".planning/${PLAN_ID}\"; SCOPE=\"scoped\"; elif [ -f .planning/.active_plan ]; then AP=$(tr -d '\\r\\n[:space:]' < .planning/.active_plan 2>/dev/null); if [ -n \"$AP\" ] && printf \"%s\" \"$AP\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${AP}\" ]; then RESOLVED=\".planning/${AP}\"; SCOPE=\"scoped\"; fi; fi; if [ -z \"$RESOLVED\" ] && [ -d .planning ]; then NEWEST=\"\"; NEWEST_MT=0; for d in .planning/*/; do d=\"${d%/}\"; n=$(basename \"$d\"); case \"$n\" in .*) continue;; esac; printf \"%s\" \"$n\" | grep -Eq \"$SLUG_RE\" || continue; [ -f \"$d/task_plan.md\" ] || continue; m=$(stat -c '%Y' \"$d\" 2>/dev/null || stat -f '%m' \"$d\" 2>/dev/null || date -r \"$d\" +%s 2>/dev/null || echo 0); if [ \"$m\" -gt \"$NEWEST_MT\" ] 2>/dev/null; then NEWEST_MT=\"$m\"; NEWEST=\"$d\"; fi; done; [ -n \"$NEWEST\" ] && { RESOLVED=\"$NEWEST\"; SCOPE=\"scoped\"; }; fi; if [ -z \"$RESOLVED\" ] && [ -f task_plan.md ]; then RESOLVED=\".\"; SCOPE=\"root\"; fi; [ -z \"$RESOLVED\" ] && exit 0; if [ \"$SCOPE\" = \"root\" ]; then PLAN_FILE=\"task_plan.md\"; PROGRESS_FILE=\"progress.md\"; ATTEST=\"\"; [ -f .plan-attestation ] && ATTEST=$(tr -d '\\r\\n[:space:]' < .plan-attestation 2>/dev/null); else PLAN_FILE=\"${RESOLVED}/task_plan.md\"; PROGRESS_FILE=\"${RESOLVED}/progress.md\"; ATTEST=\"\"; [ -f \"${RESOLVED}/.attestation\" ] && ATTEST=$(tr -d '\\r\\n[:space:]' < \"${RESOLVED}/.attestation\" 2>/dev/null); fi; [ -f \"$PLAN_FILE\" ] || exit 0; TAMPERED=0; ACTUAL=\"\"; if [ -n \"$ATTEST\" ]; then CD=\"${TMPDIR:-/tmp}/pwf-sha\"; mkdir -p \"$CD\" 2>/dev/null; KEY=$(printf \"%s\" \"$PLAN_FILE\" | { sha256sum 2>/dev/null || shasum -a 256 2>/dev/null; } | awk '{print $1}' | cut -c1-16); MT=$(stat -c '%Y' \"$PLAN_FILE\" 2>/dev/null || stat -f '%m' \"$PLAN_FILE\" 2>/dev/null || date -r \"$PLAN_FILE\" +%s 2>/dev/null || echo 0); CF=\"$CD/$KEY\"; CM=\"\"; CS=\"\"; if [ -f \"$CF\" ]; then CM=$(sed -n 1p \"$CF\" 2>/dev/null); CS=$(sed -n 2p \"$CF\" 2>/dev/null); fi; if [ -n \"$MT\" ] && [ \"$MT\" = \"$CM\" ] && [ -n \"$CS\" ]; then ACTUAL=\"$CS\"; else ACTUAL=$( (sha256sum \"$PLAN_FILE\" 2>/dev/null || shasum -a 256 \"$PLAN_FILE\" 2>/dev/null) | awk '{print $1}'); [ -n \"$ACTUAL\" ] && [ -n \"$MT\" ] && printf \"%s\\n%s\\n\" \"$MT\" \"$ACTUAL\" > \"$CF\" 2>/dev/null; fi; [ \"$ACTUAL\" != \"$ATTEST\" ] && TAMPERED=1; fi; echo '[planning-with-files] PreCompact: context compaction is about to occur.'; echo 'Before compaction completes: ensure progress.md captures recent actions and task_plan.md status reflects current phase.'; echo 'task_plan.md, findings.md, progress.md remain on disk and will be re-read after compaction.'; [ -n \"$ATTEST\" ] && echo \"Plan-SHA256 at compaction: $ATTEST\"; exit 0"
|
||||
metadata:
|
||||
version: "3.4.1"
|
||||
version: "3.5.0"
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -72,7 +72,9 @@ is_within_root() {
|
||||
root_real="$(canonicalize "${PWD}")" || root_real=""
|
||||
cand_real="$(canonicalize "${candidate}")" || cand_real=""
|
||||
if [ -z "${root_real}" ] || [ -z "${cand_real}" ]; then
|
||||
return 0
|
||||
# Slug validation blocks textual traversal, but only successful
|
||||
# canonicalization can rule out a symlink/junction escape.
|
||||
return 1
|
||||
fi
|
||||
case "${cand_real}" in
|
||||
"${root_real}"|"${root_real}"/*) return 0 ;;
|
||||
@@ -119,6 +121,12 @@ resolve_from_env() {
|
||||
resolve_from_active_file() {
|
||||
[ -f "${ACTIVE_FILE}" ] || return 1
|
||||
plan_id="$(tr -d '\r\n[:space:]' < "${ACTIVE_FILE}")"
|
||||
# UTF-8 BOM is not part of the plan id. POSIX printf octal escapes keep
|
||||
# this portable across GNU/BSD sed variants and Git-for-Windows sh.
|
||||
utf8_bom="$(printf '\357\273\277')"
|
||||
case "${plan_id}" in
|
||||
"${utf8_bom}"*) plan_id="${plan_id#"${utf8_bom}"}" ;;
|
||||
esac
|
||||
slug_is_valid "${plan_id}" || return 1
|
||||
candidate="${PLAN_ROOT}/${plan_id}"
|
||||
if [ -d "${candidate}" ] && is_within_root "${candidate}"; then
|
||||
|
||||
@@ -14,6 +14,30 @@ import os
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, Iterable, List, Optional, Tuple
|
||||
|
||||
|
||||
def configure_utf8_stdio() -> None:
|
||||
"""Make catchup output deterministic on Windows legacy code pages.
|
||||
|
||||
Codex sessions and planning files are UTF-8 and can contain arbitrary
|
||||
Unicode. Windows PowerShell may nevertheless launch Python with a cp1252
|
||||
(or another OEM/ANSI) stdout codec. A report containing Chinese text then
|
||||
used to fail at the first ``print`` with ``UnicodeEncodeError``. Configure
|
||||
both streams before any report is emitted; ``errors='replace'`` also keeps
|
||||
this advisory hook fail-safe if a malformed surrogate reaches the output.
|
||||
"""
|
||||
for stream in (sys.stdout, sys.stderr):
|
||||
reconfigure = getattr(stream, 'reconfigure', None)
|
||||
if callable(reconfigure):
|
||||
try:
|
||||
reconfigure(encoding='utf-8', errors='replace')
|
||||
except (OSError, ValueError):
|
||||
# Replaced/captured streams may not permit reconfiguration.
|
||||
# The hook remains advisory, so retain the existing stream.
|
||||
pass
|
||||
|
||||
|
||||
configure_utf8_stdio()
|
||||
|
||||
try:
|
||||
import orjson
|
||||
except ImportError:
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
# planning-with-files: set or display the active plan pointer (PowerShell).
|
||||
#
|
||||
# Usage:
|
||||
# .\set-active-plan.ps1 <plan_id> — pin .planning\.active_plan to plan_id
|
||||
# .\set-active-plan.ps1 — print the current active plan (if any)
|
||||
# .\set-active-plan.ps1 <plan_id> - pin .planning\.active_plan to plan_id
|
||||
# .\set-active-plan.ps1 - print the current active plan (if any)
|
||||
|
||||
param(
|
||||
[string]$PlanId = ""
|
||||
@@ -19,7 +19,7 @@ if ($PlanId -eq "") {
|
||||
Write-Output "Active plan: $current"
|
||||
Write-Output "Path: $planDir"
|
||||
} elseif ($current -ne "") {
|
||||
Write-Output "Active plan pointer: $current (directory not found — stale pointer)"
|
||||
Write-Output "Active plan pointer: $current (directory not found - stale pointer)"
|
||||
} else {
|
||||
Write-Output "No active plan set."
|
||||
}
|
||||
@@ -41,7 +41,8 @@ if (-not (Test-Path $PlanRoot)) {
|
||||
New-Item -ItemType Directory -Path $PlanRoot -Force | Out-Null
|
||||
}
|
||||
|
||||
Set-Content -Path $ActiveFile -Value $PlanId -Encoding UTF8 -NoNewline
|
||||
$utf8NoBom = New-Object System.Text.UTF8Encoding($false)
|
||||
[System.IO.File]::WriteAllText($ActiveFile, $PlanId, $utf8NoBom)
|
||||
|
||||
Write-Output "Active plan set to: $PlanId"
|
||||
Write-Output "Path: $PlanDir"
|
||||
|
||||
+1
-1
@@ -2,7 +2,7 @@
|
||||
"hooks": {
|
||||
"SessionStart": [
|
||||
{
|
||||
"matcher": "startup|resume",
|
||||
"matcher": "startup|resume|clear|compact",
|
||||
"hooks": [
|
||||
{
|
||||
"type": "command",
|
||||
|
||||
@@ -59,7 +59,7 @@ def is_session_attached(root: Path, session_id: str | None) -> bool:
|
||||
def emit_json(payload: dict[str, Any]) -> None:
|
||||
if not payload:
|
||||
return
|
||||
json.dump(payload, sys.stdout, ensure_ascii=False)
|
||||
json.dump(payload, sys.stdout, ensure_ascii=True)
|
||||
sys.stdout.write("\n")
|
||||
|
||||
|
||||
@@ -107,7 +107,7 @@ def _windows_git_bash() -> tuple[str | None, list[str]]:
|
||||
return None, []
|
||||
|
||||
|
||||
def run_shell_script(script_name: str, cwd: Path) -> tuple[str, str]:
|
||||
def run_shell_script(script_name: str, cwd: Path, *args: str) -> tuple[str, str]:
|
||||
sh_cmd = "sh"
|
||||
env = None
|
||||
if os.name == "nt":
|
||||
@@ -126,9 +126,11 @@ def run_shell_script(script_name: str, cwd: Path) -> tuple[str, str]:
|
||||
env.setdefault("PYTHON_BIN", sys.executable)
|
||||
|
||||
result = subprocess.run(
|
||||
[sh_cmd, str(HOOK_DIR / script_name)],
|
||||
[sh_cmd, str(HOOK_DIR / script_name), *args],
|
||||
cwd=str(cwd),
|
||||
text=True,
|
||||
encoding="utf-8",
|
||||
errors="replace",
|
||||
capture_output=True,
|
||||
check=False,
|
||||
env=env,
|
||||
|
||||
@@ -17,7 +17,10 @@ def main() -> None:
|
||||
if not adapter.is_session_attached(root, adapter.session_id_from_payload(payload)):
|
||||
return
|
||||
|
||||
plan = root / "task_plan.md"
|
||||
# Pass a relative plan root so the shell resolver returns a path that is
|
||||
# valid in both Git Bash and native Windows Python.
|
||||
plan_dir, _ = adapter.run_shell_script("resolve-plan-dir.sh", root, ".planning")
|
||||
plan = root / plan_dir / "task_plan.md" if plan_dir else root / "task_plan.md"
|
||||
if not plan.exists():
|
||||
return
|
||||
|
||||
|
||||
@@ -9,7 +9,6 @@ def main() -> None:
|
||||
root = adapter.cwd_from_payload(payload)
|
||||
|
||||
if not adapter.is_session_attached(root, adapter.session_id_from_payload(payload)):
|
||||
adapter.emit_json({"decision": "allow"})
|
||||
return
|
||||
|
||||
stdout, stderr = adapter.run_shell_script("pre-tool-use.sh", root)
|
||||
@@ -21,7 +20,12 @@ def main() -> None:
|
||||
return
|
||||
|
||||
if stderr:
|
||||
adapter.emit_json({"systemMessage": stderr})
|
||||
adapter.emit_json({
|
||||
"hookSpecificOutput": {
|
||||
"hookEventName": "PreToolUse",
|
||||
"additionalContext": stderr,
|
||||
}
|
||||
})
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@@ -1,76 +1,14 @@
|
||||
#!/bin/sh
|
||||
# planning-with-files: resolve active plan directory.
|
||||
# planning-with-files: global Codex hook resolver entry point.
|
||||
#
|
||||
# Resolution order:
|
||||
# 1. $PLAN_ID env var → ./.planning/$PLAN_ID/ if exists
|
||||
# 2. ./.planning/.active_plan content → matching dir if exists
|
||||
# 3. Newest ./.planning/<dir>/ by mtime
|
||||
# 4. Otherwise empty stdout (caller falls back to legacy ./task_plan.md)
|
||||
#
|
||||
# Always exits 0. Never errors out the agent loop.
|
||||
#
|
||||
# Usage:
|
||||
# PLAN_DIR="$(sh scripts/resolve-plan-dir.sh)"
|
||||
# PLAN_FILE="${PLAN_DIR:+$PLAN_DIR/}task_plan.md"
|
||||
# The resolver implementation is owned by the installed skill. Keep this file
|
||||
# as a thin forwarding shim so Hook and helper callers cannot silently drift
|
||||
# onto different slug/containment rules again.
|
||||
|
||||
set -u
|
||||
|
||||
PLAN_ROOT="${1:-${PWD}/.planning}"
|
||||
ACTIVE_FILE="${PLAN_ROOT}/.active_plan"
|
||||
HOOK_DIR="$(CDPATH= cd -- "$(dirname -- "$0")" 2>/dev/null && pwd)" || exit 0
|
||||
CANONICAL_RESOLVER="${HOOK_DIR}/../skills/planning-with-files/scripts/resolve-plan-dir.sh"
|
||||
|
||||
resolve_from_env() {
|
||||
plan_id="${PLAN_ID:-}"
|
||||
[ -z "${plan_id}" ] && return 1
|
||||
candidate="${PLAN_ROOT}/${plan_id}"
|
||||
if [ -d "${candidate}" ]; then
|
||||
printf "%s\n" "${candidate}"
|
||||
return 0
|
||||
fi
|
||||
return 1
|
||||
}
|
||||
|
||||
resolve_from_active_file() {
|
||||
[ -f "${ACTIVE_FILE}" ] || return 1
|
||||
plan_id="$(tr -d '\r\n' < "${ACTIVE_FILE}")"
|
||||
[ -z "${plan_id}" ] && return 1
|
||||
candidate="${PLAN_ROOT}/${plan_id}"
|
||||
if [ -d "${candidate}" ]; then
|
||||
printf "%s\n" "${candidate}"
|
||||
return 0
|
||||
fi
|
||||
return 1
|
||||
}
|
||||
|
||||
resolve_latest_dir() {
|
||||
[ -d "${PLAN_ROOT}" ] || return 1
|
||||
# Portable newest-mtime selector. Avoid `ls -t` BSD/GNU drift.
|
||||
# Only consider dirs that contain task_plan.md — skips system dirs like sessions/.
|
||||
latest=""
|
||||
latest_mtime=0
|
||||
for entry in "${PLAN_ROOT}"/*/; do
|
||||
[ -d "${entry}" ] || continue
|
||||
# Strip trailing slash
|
||||
clean="${entry%/}"
|
||||
# Skip hidden dirs
|
||||
case "$(basename "${clean}")" in
|
||||
.*) continue ;;
|
||||
esac
|
||||
# Skip dirs that are not plan dirs
|
||||
[ -f "${clean}/task_plan.md" ] || continue
|
||||
mtime="$(date -r "${clean}" +%s 2>/dev/null || stat -c '%Y' "${clean}" 2>/dev/null || echo 0)"
|
||||
if [ "${mtime}" -gt "${latest_mtime}" ] 2>/dev/null; then
|
||||
latest_mtime="${mtime}"
|
||||
latest="${clean}"
|
||||
fi
|
||||
done
|
||||
if [ -n "${latest}" ]; then
|
||||
printf "%s\n" "${latest}"
|
||||
return 0
|
||||
fi
|
||||
return 1
|
||||
}
|
||||
|
||||
if resolve_from_env; then exit 0; fi
|
||||
if resolve_from_active_file; then exit 0; fi
|
||||
if resolve_latest_dir; then exit 0; fi
|
||||
exit 0
|
||||
[ -f "${CANONICAL_RESOLVER}" ] || exit 0
|
||||
exec sh "${CANONICAL_RESOLVER}" "$@"
|
||||
|
||||
+27
-2
@@ -13,6 +13,7 @@ hook runs and print its stdout. Never used on unix. Always exits 0.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import sys
|
||||
|
||||
import codex_hook_adapter as adapter
|
||||
@@ -25,8 +26,32 @@ def main() -> None:
|
||||
payload = adapter.load_payload()
|
||||
root = adapter.cwd_from_payload(payload)
|
||||
stdout, _ = adapter.run_shell_script(script_name, root)
|
||||
if stdout:
|
||||
sys.stdout.write(stdout + "\n")
|
||||
if not stdout:
|
||||
return
|
||||
|
||||
context_events = {
|
||||
"session-start.sh": "SessionStart",
|
||||
"user-prompt-submit.sh": "UserPromptSubmit",
|
||||
}
|
||||
if script_name in context_events:
|
||||
result = {
|
||||
"hookSpecificOutput": {
|
||||
"hookEventName": context_events[script_name],
|
||||
"additionalContext": stdout,
|
||||
}
|
||||
}
|
||||
sys.stdout.write(json.dumps(result, ensure_ascii=True) + "\n")
|
||||
return
|
||||
|
||||
if script_name == "pre-compact.sh":
|
||||
result = {
|
||||
"continue": True,
|
||||
"systemMessage": stdout,
|
||||
}
|
||||
sys.stdout.write(json.dumps(result, ensure_ascii=True) + "\n")
|
||||
return
|
||||
|
||||
sys.stdout.write(stdout + "\n")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@@ -28,7 +28,7 @@ hooks:
|
||||
- type: command
|
||||
command: "RESOLVED=\"\"; SCOPE=\"\"; SLUG_RE='^[A-Za-z0-9_][A-Za-z0-9._-]*$'; if [ -n \"${PLAN_ID:-}\" ] && printf \"%s\" \"$PLAN_ID\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${PLAN_ID}\" ]; then RESOLVED=\".planning/${PLAN_ID}\"; SCOPE=\"scoped\"; elif [ -f .planning/.active_plan ]; then AP=$(tr -d '\\r\\n[:space:]' < .planning/.active_plan 2>/dev/null); if [ -n \"$AP\" ] && printf \"%s\" \"$AP\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${AP}\" ]; then RESOLVED=\".planning/${AP}\"; SCOPE=\"scoped\"; fi; fi; if [ -z \"$RESOLVED\" ] && [ -d .planning ]; then NEWEST=\"\"; NEWEST_MT=0; for d in .planning/*/; do d=\"${d%/}\"; n=$(basename \"$d\"); case \"$n\" in .*) continue;; esac; printf \"%s\" \"$n\" | grep -Eq \"$SLUG_RE\" || continue; [ -f \"$d/task_plan.md\" ] || continue; m=$(stat -c '%Y' \"$d\" 2>/dev/null || stat -f '%m' \"$d\" 2>/dev/null || date -r \"$d\" +%s 2>/dev/null || echo 0); if [ \"$m\" -gt \"$NEWEST_MT\" ] 2>/dev/null; then NEWEST_MT=\"$m\"; NEWEST=\"$d\"; fi; done; [ -n \"$NEWEST\" ] && { RESOLVED=\"$NEWEST\"; SCOPE=\"scoped\"; }; fi; if [ -z \"$RESOLVED\" ] && [ -f task_plan.md ]; then RESOLVED=\".\"; SCOPE=\"root\"; fi; [ -z \"$RESOLVED\" ] && exit 0; if [ \"$SCOPE\" = \"root\" ]; then PLAN_FILE=\"task_plan.md\"; PROGRESS_FILE=\"progress.md\"; ATTEST=\"\"; [ -f .plan-attestation ] && ATTEST=$(tr -d '\\r\\n[:space:]' < .plan-attestation 2>/dev/null); else PLAN_FILE=\"${RESOLVED}/task_plan.md\"; PROGRESS_FILE=\"${RESOLVED}/progress.md\"; ATTEST=\"\"; [ -f \"${RESOLVED}/.attestation\" ] && ATTEST=$(tr -d '\\r\\n[:space:]' < \"${RESOLVED}/.attestation\" 2>/dev/null); fi; [ -f \"$PLAN_FILE\" ] || exit 0; TAMPERED=0; ACTUAL=\"\"; if [ -n \"$ATTEST\" ]; then CD=\"${TMPDIR:-/tmp}/pwf-sha\"; mkdir -p \"$CD\" 2>/dev/null; KEY=$(printf \"%s\" \"$PLAN_FILE\" | { sha256sum 2>/dev/null || shasum -a 256 2>/dev/null; } | awk '{print $1}' | cut -c1-16); MT=$(stat -c '%Y' \"$PLAN_FILE\" 2>/dev/null || stat -f '%m' \"$PLAN_FILE\" 2>/dev/null || date -r \"$PLAN_FILE\" +%s 2>/dev/null || echo 0); CF=\"$CD/$KEY\"; CM=\"\"; CS=\"\"; if [ -f \"$CF\" ]; then CM=$(sed -n 1p \"$CF\" 2>/dev/null); CS=$(sed -n 2p \"$CF\" 2>/dev/null); fi; if [ -n \"$MT\" ] && [ \"$MT\" = \"$CM\" ] && [ -n \"$CS\" ]; then ACTUAL=\"$CS\"; else ACTUAL=$( (sha256sum \"$PLAN_FILE\" 2>/dev/null || shasum -a 256 \"$PLAN_FILE\" 2>/dev/null) | awk '{print $1}'); [ -n \"$ACTUAL\" ] && [ -n \"$MT\" ] && printf \"%s\\n%s\\n\" \"$MT\" \"$ACTUAL\" > \"$CF\" 2>/dev/null; fi; [ \"$ACTUAL\" != \"$ATTEST\" ] && TAMPERED=1; fi; echo '[planning-with-files] PreCompact: context compaction is about to occur.'; echo 'Before compaction completes: ensure progress.md captures recent actions and task_plan.md status reflects current phase.'; echo 'task_plan.md, findings.md, progress.md remain on disk and will be re-read after compaction.'; [ -n \"$ATTEST\" ] && echo \"Plan-SHA256 at compaction: $ATTEST\"; exit 0"
|
||||
metadata:
|
||||
version: "3.4.1"
|
||||
version: "3.5.0"
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -72,7 +72,9 @@ is_within_root() {
|
||||
root_real="$(canonicalize "${PWD}")" || root_real=""
|
||||
cand_real="$(canonicalize "${candidate}")" || cand_real=""
|
||||
if [ -z "${root_real}" ] || [ -z "${cand_real}" ]; then
|
||||
return 0
|
||||
# Slug validation blocks textual traversal, but only successful
|
||||
# canonicalization can rule out a symlink/junction escape.
|
||||
return 1
|
||||
fi
|
||||
case "${cand_real}" in
|
||||
"${root_real}"|"${root_real}"/*) return 0 ;;
|
||||
@@ -119,6 +121,12 @@ resolve_from_env() {
|
||||
resolve_from_active_file() {
|
||||
[ -f "${ACTIVE_FILE}" ] || return 1
|
||||
plan_id="$(tr -d '\r\n[:space:]' < "${ACTIVE_FILE}")"
|
||||
# UTF-8 BOM is not part of the plan id. POSIX printf octal escapes keep
|
||||
# this portable across GNU/BSD sed variants and Git-for-Windows sh.
|
||||
utf8_bom="$(printf '\357\273\277')"
|
||||
case "${plan_id}" in
|
||||
"${utf8_bom}"*) plan_id="${plan_id#"${utf8_bom}"}" ;;
|
||||
esac
|
||||
slug_is_valid "${plan_id}" || return 1
|
||||
candidate="${PLAN_ROOT}/${plan_id}"
|
||||
if [ -d "${candidate}" ] && is_within_root "${candidate}"; then
|
||||
|
||||
@@ -14,6 +14,30 @@ import os
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, Iterable, List, Optional, Tuple
|
||||
|
||||
|
||||
def configure_utf8_stdio() -> None:
|
||||
"""Make catchup output deterministic on Windows legacy code pages.
|
||||
|
||||
Codex sessions and planning files are UTF-8 and can contain arbitrary
|
||||
Unicode. Windows PowerShell may nevertheless launch Python with a cp1252
|
||||
(or another OEM/ANSI) stdout codec. A report containing Chinese text then
|
||||
used to fail at the first ``print`` with ``UnicodeEncodeError``. Configure
|
||||
both streams before any report is emitted; ``errors='replace'`` also keeps
|
||||
this advisory hook fail-safe if a malformed surrogate reaches the output.
|
||||
"""
|
||||
for stream in (sys.stdout, sys.stderr):
|
||||
reconfigure = getattr(stream, 'reconfigure', None)
|
||||
if callable(reconfigure):
|
||||
try:
|
||||
reconfigure(encoding='utf-8', errors='replace')
|
||||
except (OSError, ValueError):
|
||||
# Replaced/captured streams may not permit reconfiguration.
|
||||
# The hook remains advisory, so retain the existing stream.
|
||||
pass
|
||||
|
||||
|
||||
configure_utf8_stdio()
|
||||
|
||||
try:
|
||||
import orjson
|
||||
except ImportError:
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
# planning-with-files: set or display the active plan pointer (PowerShell).
|
||||
#
|
||||
# Usage:
|
||||
# .\set-active-plan.ps1 <plan_id> — pin .planning\.active_plan to plan_id
|
||||
# .\set-active-plan.ps1 — print the current active plan (if any)
|
||||
# .\set-active-plan.ps1 <plan_id> - pin .planning\.active_plan to plan_id
|
||||
# .\set-active-plan.ps1 - print the current active plan (if any)
|
||||
|
||||
param(
|
||||
[string]$PlanId = ""
|
||||
@@ -19,7 +19,7 @@ if ($PlanId -eq "") {
|
||||
Write-Output "Active plan: $current"
|
||||
Write-Output "Path: $planDir"
|
||||
} elseif ($current -ne "") {
|
||||
Write-Output "Active plan pointer: $current (directory not found — stale pointer)"
|
||||
Write-Output "Active plan pointer: $current (directory not found - stale pointer)"
|
||||
} else {
|
||||
Write-Output "No active plan set."
|
||||
}
|
||||
@@ -41,7 +41,8 @@ if (-not (Test-Path $PlanRoot)) {
|
||||
New-Item -ItemType Directory -Path $PlanRoot -Force | Out-Null
|
||||
}
|
||||
|
||||
Set-Content -Path $ActiveFile -Value $PlanId -Encoding UTF8 -NoNewline
|
||||
$utf8NoBom = New-Object System.Text.UTF8Encoding($false)
|
||||
[System.IO.File]::WriteAllText($ActiveFile, $PlanId, $utf8NoBom)
|
||||
|
||||
Write-Output "Active plan set to: $PlanId"
|
||||
Write-Output "Path: $PlanDir"
|
||||
|
||||
@@ -72,7 +72,9 @@ is_within_root() {
|
||||
root_real="$(canonicalize "${PWD}")" || root_real=""
|
||||
cand_real="$(canonicalize "${candidate}")" || cand_real=""
|
||||
if [ -z "${root_real}" ] || [ -z "${cand_real}" ]; then
|
||||
return 0
|
||||
# Slug validation blocks textual traversal, but only successful
|
||||
# canonicalization can rule out a symlink/junction escape.
|
||||
return 1
|
||||
fi
|
||||
case "${cand_real}" in
|
||||
"${root_real}"|"${root_real}"/*) return 0 ;;
|
||||
@@ -119,6 +121,12 @@ resolve_from_env() {
|
||||
resolve_from_active_file() {
|
||||
[ -f "${ACTIVE_FILE}" ] || return 1
|
||||
plan_id="$(tr -d '\r\n[:space:]' < "${ACTIVE_FILE}")"
|
||||
# UTF-8 BOM is not part of the plan id. POSIX printf octal escapes keep
|
||||
# this portable across GNU/BSD sed variants and Git-for-Windows sh.
|
||||
utf8_bom="$(printf '\357\273\277')"
|
||||
case "${plan_id}" in
|
||||
"${utf8_bom}"*) plan_id="${plan_id#"${utf8_bom}"}" ;;
|
||||
esac
|
||||
slug_is_valid "${plan_id}" || return 1
|
||||
candidate="${PLAN_ROOT}/${plan_id}"
|
||||
if [ -d "${candidate}" ] && is_within_root "${candidate}"; then
|
||||
|
||||
@@ -14,6 +14,30 @@ import os
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, Iterable, List, Optional, Tuple
|
||||
|
||||
|
||||
def configure_utf8_stdio() -> None:
|
||||
"""Make catchup output deterministic on Windows legacy code pages.
|
||||
|
||||
Codex sessions and planning files are UTF-8 and can contain arbitrary
|
||||
Unicode. Windows PowerShell may nevertheless launch Python with a cp1252
|
||||
(or another OEM/ANSI) stdout codec. A report containing Chinese text then
|
||||
used to fail at the first ``print`` with ``UnicodeEncodeError``. Configure
|
||||
both streams before any report is emitted; ``errors='replace'`` also keeps
|
||||
this advisory hook fail-safe if a malformed surrogate reaches the output.
|
||||
"""
|
||||
for stream in (sys.stdout, sys.stderr):
|
||||
reconfigure = getattr(stream, 'reconfigure', None)
|
||||
if callable(reconfigure):
|
||||
try:
|
||||
reconfigure(encoding='utf-8', errors='replace')
|
||||
except (OSError, ValueError):
|
||||
# Replaced/captured streams may not permit reconfiguration.
|
||||
# The hook remains advisory, so retain the existing stream.
|
||||
pass
|
||||
|
||||
|
||||
configure_utf8_stdio()
|
||||
|
||||
try:
|
||||
import orjson
|
||||
except ImportError:
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
# planning-with-files: set or display the active plan pointer (PowerShell).
|
||||
#
|
||||
# Usage:
|
||||
# .\set-active-plan.ps1 <plan_id> — pin .planning\.active_plan to plan_id
|
||||
# .\set-active-plan.ps1 — print the current active plan (if any)
|
||||
# .\set-active-plan.ps1 <plan_id> - pin .planning\.active_plan to plan_id
|
||||
# .\set-active-plan.ps1 - print the current active plan (if any)
|
||||
|
||||
param(
|
||||
[string]$PlanId = ""
|
||||
@@ -19,7 +19,7 @@ if ($PlanId -eq "") {
|
||||
Write-Output "Active plan: $current"
|
||||
Write-Output "Path: $planDir"
|
||||
} elseif ($current -ne "") {
|
||||
Write-Output "Active plan pointer: $current (directory not found — stale pointer)"
|
||||
Write-Output "Active plan pointer: $current (directory not found - stale pointer)"
|
||||
} else {
|
||||
Write-Output "No active plan set."
|
||||
}
|
||||
@@ -41,7 +41,8 @@ if (-not (Test-Path $PlanRoot)) {
|
||||
New-Item -ItemType Directory -Path $PlanRoot -Force | Out-Null
|
||||
}
|
||||
|
||||
Set-Content -Path $ActiveFile -Value $PlanId -Encoding UTF8 -NoNewline
|
||||
$utf8NoBom = New-Object System.Text.UTF8Encoding($false)
|
||||
[System.IO.File]::WriteAllText($ActiveFile, $PlanId, $utf8NoBom)
|
||||
|
||||
Write-Output "Active plan set to: $PlanId"
|
||||
Write-Output "Path: $PlanDir"
|
||||
|
||||
@@ -28,7 +28,7 @@ hooks:
|
||||
- type: command
|
||||
command: "RESOLVED=\"\"; SCOPE=\"\"; SLUG_RE='^[A-Za-z0-9_][A-Za-z0-9._-]*$'; if [ -n \"${PLAN_ID:-}\" ] && printf \"%s\" \"$PLAN_ID\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${PLAN_ID}\" ]; then RESOLVED=\".planning/${PLAN_ID}\"; SCOPE=\"scoped\"; elif [ -f .planning/.active_plan ]; then AP=$(tr -d '\\r\\n[:space:]' < .planning/.active_plan 2>/dev/null); if [ -n \"$AP\" ] && printf \"%s\" \"$AP\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${AP}\" ]; then RESOLVED=\".planning/${AP}\"; SCOPE=\"scoped\"; fi; fi; if [ -z \"$RESOLVED\" ] && [ -d .planning ]; then NEWEST=\"\"; NEWEST_MT=0; for d in .planning/*/; do d=\"${d%/}\"; n=$(basename \"$d\"); case \"$n\" in .*) continue;; esac; printf \"%s\" \"$n\" | grep -Eq \"$SLUG_RE\" || continue; [ -f \"$d/task_plan.md\" ] || continue; m=$(stat -c '%Y' \"$d\" 2>/dev/null || stat -f '%m' \"$d\" 2>/dev/null || date -r \"$d\" +%s 2>/dev/null || echo 0); if [ \"$m\" -gt \"$NEWEST_MT\" ] 2>/dev/null; then NEWEST_MT=\"$m\"; NEWEST=\"$d\"; fi; done; [ -n \"$NEWEST\" ] && { RESOLVED=\"$NEWEST\"; SCOPE=\"scoped\"; }; fi; if [ -z \"$RESOLVED\" ] && [ -f task_plan.md ]; then RESOLVED=\".\"; SCOPE=\"root\"; fi; [ -z \"$RESOLVED\" ] && exit 0; if [ \"$SCOPE\" = \"root\" ]; then PLAN_FILE=\"task_plan.md\"; PROGRESS_FILE=\"progress.md\"; ATTEST=\"\"; [ -f .plan-attestation ] && ATTEST=$(tr -d '\\r\\n[:space:]' < .plan-attestation 2>/dev/null); else PLAN_FILE=\"${RESOLVED}/task_plan.md\"; PROGRESS_FILE=\"${RESOLVED}/progress.md\"; ATTEST=\"\"; [ -f \"${RESOLVED}/.attestation\" ] && ATTEST=$(tr -d '\\r\\n[:space:]' < \"${RESOLVED}/.attestation\" 2>/dev/null); fi; [ -f \"$PLAN_FILE\" ] || exit 0; TAMPERED=0; ACTUAL=\"\"; if [ -n \"$ATTEST\" ]; then CD=\"${TMPDIR:-/tmp}/pwf-sha\"; mkdir -p \"$CD\" 2>/dev/null; KEY=$(printf \"%s\" \"$PLAN_FILE\" | { sha256sum 2>/dev/null || shasum -a 256 2>/dev/null; } | awk '{print $1}' | cut -c1-16); MT=$(stat -c '%Y' \"$PLAN_FILE\" 2>/dev/null || stat -f '%m' \"$PLAN_FILE\" 2>/dev/null || date -r \"$PLAN_FILE\" +%s 2>/dev/null || echo 0); CF=\"$CD/$KEY\"; CM=\"\"; CS=\"\"; if [ -f \"$CF\" ]; then CM=$(sed -n 1p \"$CF\" 2>/dev/null); CS=$(sed -n 2p \"$CF\" 2>/dev/null); fi; if [ -n \"$MT\" ] && [ \"$MT\" = \"$CM\" ] && [ -n \"$CS\" ]; then ACTUAL=\"$CS\"; else ACTUAL=$( (sha256sum \"$PLAN_FILE\" 2>/dev/null || shasum -a 256 \"$PLAN_FILE\" 2>/dev/null) | awk '{print $1}'); [ -n \"$ACTUAL\" ] && [ -n \"$MT\" ] && printf \"%s\\n%s\\n\" \"$MT\" \"$ACTUAL\" > \"$CF\" 2>/dev/null; fi; [ \"$ACTUAL\" != \"$ATTEST\" ] && TAMPERED=1; fi; echo '[planning-with-files] PreCompact: context compaction is about to occur.'; echo 'Before compaction completes: ensure progress.md captures recent actions and task_plan.md status reflects current phase.'; echo 'task_plan.md, findings.md, progress.md remain on disk and will be re-read after compaction.'; [ -n \"$ATTEST\" ] && echo \"Plan-SHA256 at compaction: $ATTEST\"; exit 0"
|
||||
metadata:
|
||||
version: "3.4.1"
|
||||
version: "3.5.0"
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -28,7 +28,7 @@ hooks:
|
||||
- type: command
|
||||
command: "RESOLVED=\"\"; SCOPE=\"\"; SLUG_RE='^[A-Za-z0-9_][A-Za-z0-9._-]*$'; if [ -n \"${PLAN_ID:-}\" ] && printf \"%s\" \"$PLAN_ID\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${PLAN_ID}\" ]; then RESOLVED=\".planning/${PLAN_ID}\"; SCOPE=\"scoped\"; elif [ -f .planning/.active_plan ]; then AP=$(tr -d '\\r\\n[:space:]' < .planning/.active_plan 2>/dev/null); if [ -n \"$AP\" ] && printf \"%s\" \"$AP\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${AP}\" ]; then RESOLVED=\".planning/${AP}\"; SCOPE=\"scoped\"; fi; fi; if [ -z \"$RESOLVED\" ] && [ -d .planning ]; then NEWEST=\"\"; NEWEST_MT=0; for d in .planning/*/; do d=\"${d%/}\"; n=$(basename \"$d\"); case \"$n\" in .*) continue;; esac; printf \"%s\" \"$n\" | grep -Eq \"$SLUG_RE\" || continue; [ -f \"$d/task_plan.md\" ] || continue; m=$(stat -c '%Y' \"$d\" 2>/dev/null || stat -f '%m' \"$d\" 2>/dev/null || date -r \"$d\" +%s 2>/dev/null || echo 0); if [ \"$m\" -gt \"$NEWEST_MT\" ] 2>/dev/null; then NEWEST_MT=\"$m\"; NEWEST=\"$d\"; fi; done; [ -n \"$NEWEST\" ] && { RESOLVED=\"$NEWEST\"; SCOPE=\"scoped\"; }; fi; if [ -z \"$RESOLVED\" ] && [ -f task_plan.md ]; then RESOLVED=\".\"; SCOPE=\"root\"; fi; [ -z \"$RESOLVED\" ] && exit 0; if [ \"$SCOPE\" = \"root\" ]; then PLAN_FILE=\"task_plan.md\"; PROGRESS_FILE=\"progress.md\"; ATTEST=\"\"; [ -f .plan-attestation ] && ATTEST=$(tr -d '\\r\\n[:space:]' < .plan-attestation 2>/dev/null); else PLAN_FILE=\"${RESOLVED}/task_plan.md\"; PROGRESS_FILE=\"${RESOLVED}/progress.md\"; ATTEST=\"\"; [ -f \"${RESOLVED}/.attestation\" ] && ATTEST=$(tr -d '\\r\\n[:space:]' < \"${RESOLVED}/.attestation\" 2>/dev/null); fi; [ -f \"$PLAN_FILE\" ] || exit 0; TAMPERED=0; ACTUAL=\"\"; if [ -n \"$ATTEST\" ]; then CD=\"${TMPDIR:-/tmp}/pwf-sha\"; mkdir -p \"$CD\" 2>/dev/null; KEY=$(printf \"%s\" \"$PLAN_FILE\" | { sha256sum 2>/dev/null || shasum -a 256 2>/dev/null; } | awk '{print $1}' | cut -c1-16); MT=$(stat -c '%Y' \"$PLAN_FILE\" 2>/dev/null || stat -f '%m' \"$PLAN_FILE\" 2>/dev/null || date -r \"$PLAN_FILE\" +%s 2>/dev/null || echo 0); CF=\"$CD/$KEY\"; CM=\"\"; CS=\"\"; if [ -f \"$CF\" ]; then CM=$(sed -n 1p \"$CF\" 2>/dev/null); CS=$(sed -n 2p \"$CF\" 2>/dev/null); fi; if [ -n \"$MT\" ] && [ \"$MT\" = \"$CM\" ] && [ -n \"$CS\" ]; then ACTUAL=\"$CS\"; else ACTUAL=$( (sha256sum \"$PLAN_FILE\" 2>/dev/null || shasum -a 256 \"$PLAN_FILE\" 2>/dev/null) | awk '{print $1}'); [ -n \"$ACTUAL\" ] && [ -n \"$MT\" ] && printf \"%s\\n%s\\n\" \"$MT\" \"$ACTUAL\" > \"$CF\" 2>/dev/null; fi; [ \"$ACTUAL\" != \"$ATTEST\" ] && TAMPERED=1; fi; echo '[planning-with-files] PreCompact: context compaction is about to occur.'; echo 'Before compaction completes: ensure progress.md captures recent actions and task_plan.md status reflects current phase.'; echo 'task_plan.md, findings.md, progress.md remain on disk and will be re-read after compaction.'; [ -n \"$ATTEST\" ] && echo \"Plan-SHA256 at compaction: $ATTEST\"; exit 0"
|
||||
metadata:
|
||||
version: "3.4.1"
|
||||
version: "3.5.0"
|
||||
---
|
||||
|
||||
# Planning with Files
|
||||
|
||||
@@ -72,7 +72,9 @@ is_within_root() {
|
||||
root_real="$(canonicalize "${PWD}")" || root_real=""
|
||||
cand_real="$(canonicalize "${candidate}")" || cand_real=""
|
||||
if [ -z "${root_real}" ] || [ -z "${cand_real}" ]; then
|
||||
return 0
|
||||
# Slug validation blocks textual traversal, but only successful
|
||||
# canonicalization can rule out a symlink/junction escape.
|
||||
return 1
|
||||
fi
|
||||
case "${cand_real}" in
|
||||
"${root_real}"|"${root_real}"/*) return 0 ;;
|
||||
@@ -119,6 +121,12 @@ resolve_from_env() {
|
||||
resolve_from_active_file() {
|
||||
[ -f "${ACTIVE_FILE}" ] || return 1
|
||||
plan_id="$(tr -d '\r\n[:space:]' < "${ACTIVE_FILE}")"
|
||||
# UTF-8 BOM is not part of the plan id. POSIX printf octal escapes keep
|
||||
# this portable across GNU/BSD sed variants and Git-for-Windows sh.
|
||||
utf8_bom="$(printf '\357\273\277')"
|
||||
case "${plan_id}" in
|
||||
"${utf8_bom}"*) plan_id="${plan_id#"${utf8_bom}"}" ;;
|
||||
esac
|
||||
slug_is_valid "${plan_id}" || return 1
|
||||
candidate="${PLAN_ROOT}/${plan_id}"
|
||||
if [ -d "${candidate}" ] && is_within_root "${candidate}"; then
|
||||
|
||||
@@ -14,6 +14,30 @@ import os
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, Iterable, List, Optional, Tuple
|
||||
|
||||
|
||||
def configure_utf8_stdio() -> None:
|
||||
"""Make catchup output deterministic on Windows legacy code pages.
|
||||
|
||||
Codex sessions and planning files are UTF-8 and can contain arbitrary
|
||||
Unicode. Windows PowerShell may nevertheless launch Python with a cp1252
|
||||
(or another OEM/ANSI) stdout codec. A report containing Chinese text then
|
||||
used to fail at the first ``print`` with ``UnicodeEncodeError``. Configure
|
||||
both streams before any report is emitted; ``errors='replace'`` also keeps
|
||||
this advisory hook fail-safe if a malformed surrogate reaches the output.
|
||||
"""
|
||||
for stream in (sys.stdout, sys.stderr):
|
||||
reconfigure = getattr(stream, 'reconfigure', None)
|
||||
if callable(reconfigure):
|
||||
try:
|
||||
reconfigure(encoding='utf-8', errors='replace')
|
||||
except (OSError, ValueError):
|
||||
# Replaced/captured streams may not permit reconfiguration.
|
||||
# The hook remains advisory, so retain the existing stream.
|
||||
pass
|
||||
|
||||
|
||||
configure_utf8_stdio()
|
||||
|
||||
try:
|
||||
import orjson
|
||||
except ImportError:
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
# planning-with-files: set or display the active plan pointer (PowerShell).
|
||||
#
|
||||
# Usage:
|
||||
# .\set-active-plan.ps1 <plan_id> — pin .planning\.active_plan to plan_id
|
||||
# .\set-active-plan.ps1 — print the current active plan (if any)
|
||||
# .\set-active-plan.ps1 <plan_id> - pin .planning\.active_plan to plan_id
|
||||
# .\set-active-plan.ps1 - print the current active plan (if any)
|
||||
|
||||
param(
|
||||
[string]$PlanId = ""
|
||||
@@ -19,7 +19,7 @@ if ($PlanId -eq "") {
|
||||
Write-Output "Active plan: $current"
|
||||
Write-Output "Path: $planDir"
|
||||
} elseif ($current -ne "") {
|
||||
Write-Output "Active plan pointer: $current (directory not found — stale pointer)"
|
||||
Write-Output "Active plan pointer: $current (directory not found - stale pointer)"
|
||||
} else {
|
||||
Write-Output "No active plan set."
|
||||
}
|
||||
@@ -41,7 +41,8 @@ if (-not (Test-Path $PlanRoot)) {
|
||||
New-Item -ItemType Directory -Path $PlanRoot -Force | Out-Null
|
||||
}
|
||||
|
||||
Set-Content -Path $ActiveFile -Value $PlanId -Encoding UTF8 -NoNewline
|
||||
$utf8NoBom = New-Object System.Text.UTF8Encoding($false)
|
||||
[System.IO.File]::WriteAllText($ActiveFile, $PlanId, $utf8NoBom)
|
||||
|
||||
Write-Output "Active plan set to: $PlanId"
|
||||
Write-Output "Path: $PlanDir"
|
||||
|
||||
@@ -72,7 +72,9 @@ is_within_root() {
|
||||
root_real="$(canonicalize "${PWD}")" || root_real=""
|
||||
cand_real="$(canonicalize "${candidate}")" || cand_real=""
|
||||
if [ -z "${root_real}" ] || [ -z "${cand_real}" ]; then
|
||||
return 0
|
||||
# Slug validation blocks textual traversal, but only successful
|
||||
# canonicalization can rule out a symlink/junction escape.
|
||||
return 1
|
||||
fi
|
||||
case "${cand_real}" in
|
||||
"${root_real}"|"${root_real}"/*) return 0 ;;
|
||||
@@ -119,6 +121,12 @@ resolve_from_env() {
|
||||
resolve_from_active_file() {
|
||||
[ -f "${ACTIVE_FILE}" ] || return 1
|
||||
plan_id="$(tr -d '\r\n[:space:]' < "${ACTIVE_FILE}")"
|
||||
# UTF-8 BOM is not part of the plan id. POSIX printf octal escapes keep
|
||||
# this portable across GNU/BSD sed variants and Git-for-Windows sh.
|
||||
utf8_bom="$(printf '\357\273\277')"
|
||||
case "${plan_id}" in
|
||||
"${utf8_bom}"*) plan_id="${plan_id#"${utf8_bom}"}" ;;
|
||||
esac
|
||||
slug_is_valid "${plan_id}" || return 1
|
||||
candidate="${PLAN_ROOT}/${plan_id}"
|
||||
if [ -d "${candidate}" ] && is_within_root "${candidate}"; then
|
||||
|
||||
@@ -14,6 +14,30 @@ import os
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, Iterable, List, Optional, Tuple
|
||||
|
||||
|
||||
def configure_utf8_stdio() -> None:
|
||||
"""Make catchup output deterministic on Windows legacy code pages.
|
||||
|
||||
Codex sessions and planning files are UTF-8 and can contain arbitrary
|
||||
Unicode. Windows PowerShell may nevertheless launch Python with a cp1252
|
||||
(or another OEM/ANSI) stdout codec. A report containing Chinese text then
|
||||
used to fail at the first ``print`` with ``UnicodeEncodeError``. Configure
|
||||
both streams before any report is emitted; ``errors='replace'`` also keeps
|
||||
this advisory hook fail-safe if a malformed surrogate reaches the output.
|
||||
"""
|
||||
for stream in (sys.stdout, sys.stderr):
|
||||
reconfigure = getattr(stream, 'reconfigure', None)
|
||||
if callable(reconfigure):
|
||||
try:
|
||||
reconfigure(encoding='utf-8', errors='replace')
|
||||
except (OSError, ValueError):
|
||||
# Replaced/captured streams may not permit reconfiguration.
|
||||
# The hook remains advisory, so retain the existing stream.
|
||||
pass
|
||||
|
||||
|
||||
configure_utf8_stdio()
|
||||
|
||||
try:
|
||||
import orjson
|
||||
except ImportError:
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
# planning-with-files: set or display the active plan pointer (PowerShell).
|
||||
#
|
||||
# Usage:
|
||||
# .\set-active-plan.ps1 <plan_id> — pin .planning\.active_plan to plan_id
|
||||
# .\set-active-plan.ps1 — print the current active plan (if any)
|
||||
# .\set-active-plan.ps1 <plan_id> - pin .planning\.active_plan to plan_id
|
||||
# .\set-active-plan.ps1 - print the current active plan (if any)
|
||||
|
||||
param(
|
||||
[string]$PlanId = ""
|
||||
@@ -19,7 +19,7 @@ if ($PlanId -eq "") {
|
||||
Write-Output "Active plan: $current"
|
||||
Write-Output "Path: $planDir"
|
||||
} elseif ($current -ne "") {
|
||||
Write-Output "Active plan pointer: $current (directory not found — stale pointer)"
|
||||
Write-Output "Active plan pointer: $current (directory not found - stale pointer)"
|
||||
} else {
|
||||
Write-Output "No active plan set."
|
||||
}
|
||||
@@ -41,7 +41,8 @@ if (-not (Test-Path $PlanRoot)) {
|
||||
New-Item -ItemType Directory -Path $PlanRoot -Force | Out-Null
|
||||
}
|
||||
|
||||
Set-Content -Path $ActiveFile -Value $PlanId -Encoding UTF8 -NoNewline
|
||||
$utf8NoBom = New-Object System.Text.UTF8Encoding($false)
|
||||
[System.IO.File]::WriteAllText($ActiveFile, $PlanId, $utf8NoBom)
|
||||
|
||||
Write-Output "Active plan set to: $PlanId"
|
||||
Write-Output "Path: $PlanDir"
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
name: planning-with-files
|
||||
description: "Manus-style persistent file-based planning for AI coding agents: keeps task_plan.md, findings.md, and progress.md on disk so work survives context loss and /clear. Use when asked to plan out, break down, or organize a multi-step project, research task, or any work requiring 5+ tool calls. Hermes adaptation with minimal notes."
|
||||
metadata:
|
||||
version: "3.4.1"
|
||||
version: "3.5.0"
|
||||
---
|
||||
|
||||
> Hermes note: lifecycle automation for this skill is provided by the Hermes adapter plugin in `.hermes/plugins/planning-with-files/`.
|
||||
|
||||
@@ -28,7 +28,7 @@ hooks:
|
||||
- type: command
|
||||
command: "RESOLVED=\"\"; SCOPE=\"\"; SLUG_RE='^[A-Za-z0-9_][A-Za-z0-9._-]*$'; if [ -n \"${PLAN_ID:-}\" ] && printf \"%s\" \"$PLAN_ID\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${PLAN_ID}\" ]; then RESOLVED=\".planning/${PLAN_ID}\"; SCOPE=\"scoped\"; elif [ -f .planning/.active_plan ]; then AP=$(tr -d '\\r\\n[:space:]' < .planning/.active_plan 2>/dev/null); if [ -n \"$AP\" ] && printf \"%s\" \"$AP\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${AP}\" ]; then RESOLVED=\".planning/${AP}\"; SCOPE=\"scoped\"; fi; fi; if [ -z \"$RESOLVED\" ] && [ -d .planning ]; then NEWEST=\"\"; NEWEST_MT=0; for d in .planning/*/; do d=\"${d%/}\"; n=$(basename \"$d\"); case \"$n\" in .*) continue;; esac; printf \"%s\" \"$n\" | grep -Eq \"$SLUG_RE\" || continue; [ -f \"$d/task_plan.md\" ] || continue; m=$(stat -c '%Y' \"$d\" 2>/dev/null || stat -f '%m' \"$d\" 2>/dev/null || date -r \"$d\" +%s 2>/dev/null || echo 0); if [ \"$m\" -gt \"$NEWEST_MT\" ] 2>/dev/null; then NEWEST_MT=\"$m\"; NEWEST=\"$d\"; fi; done; [ -n \"$NEWEST\" ] && { RESOLVED=\"$NEWEST\"; SCOPE=\"scoped\"; }; fi; if [ -z \"$RESOLVED\" ] && [ -f task_plan.md ]; then RESOLVED=\".\"; SCOPE=\"root\"; fi; [ -z \"$RESOLVED\" ] && exit 0; if [ \"$SCOPE\" = \"root\" ]; then PLAN_FILE=\"task_plan.md\"; PROGRESS_FILE=\"progress.md\"; ATTEST=\"\"; [ -f .plan-attestation ] && ATTEST=$(tr -d '\\r\\n[:space:]' < .plan-attestation 2>/dev/null); else PLAN_FILE=\"${RESOLVED}/task_plan.md\"; PROGRESS_FILE=\"${RESOLVED}/progress.md\"; ATTEST=\"\"; [ -f \"${RESOLVED}/.attestation\" ] && ATTEST=$(tr -d '\\r\\n[:space:]' < \"${RESOLVED}/.attestation\" 2>/dev/null); fi; [ -f \"$PLAN_FILE\" ] || exit 0; TAMPERED=0; ACTUAL=\"\"; if [ -n \"$ATTEST\" ]; then CD=\"${TMPDIR:-/tmp}/pwf-sha\"; mkdir -p \"$CD\" 2>/dev/null; KEY=$(printf \"%s\" \"$PLAN_FILE\" | { sha256sum 2>/dev/null || shasum -a 256 2>/dev/null; } | awk '{print $1}' | cut -c1-16); MT=$(stat -c '%Y' \"$PLAN_FILE\" 2>/dev/null || stat -f '%m' \"$PLAN_FILE\" 2>/dev/null || date -r \"$PLAN_FILE\" +%s 2>/dev/null || echo 0); CF=\"$CD/$KEY\"; CM=\"\"; CS=\"\"; if [ -f \"$CF\" ]; then CM=$(sed -n 1p \"$CF\" 2>/dev/null); CS=$(sed -n 2p \"$CF\" 2>/dev/null); fi; if [ -n \"$MT\" ] && [ \"$MT\" = \"$CM\" ] && [ -n \"$CS\" ]; then ACTUAL=\"$CS\"; else ACTUAL=$( (sha256sum \"$PLAN_FILE\" 2>/dev/null || shasum -a 256 \"$PLAN_FILE\" 2>/dev/null) | awk '{print $1}'); [ -n \"$ACTUAL\" ] && [ -n \"$MT\" ] && printf \"%s\\n%s\\n\" \"$MT\" \"$ACTUAL\" > \"$CF\" 2>/dev/null; fi; [ \"$ACTUAL\" != \"$ATTEST\" ] && TAMPERED=1; fi; echo '[planning-with-files] PreCompact: context compaction is about to occur.'; echo 'Before compaction completes: ensure progress.md captures recent actions and task_plan.md status reflects current phase.'; echo 'task_plan.md, findings.md, progress.md remain on disk and will be re-read after compaction.'; [ -n \"$ATTEST\" ] && echo \"Plan-SHA256 at compaction: $ATTEST\"; exit 0"
|
||||
metadata:
|
||||
version: "3.4.1"
|
||||
version: "3.5.0"
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -28,7 +28,7 @@ hooks:
|
||||
- type: command
|
||||
command: "RESOLVED=\"\"; SCOPE=\"\"; SLUG_RE='^[A-Za-z0-9_][A-Za-z0-9._-]*$'; if [ -n \"${PLAN_ID:-}\" ] && printf \"%s\" \"$PLAN_ID\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${PLAN_ID}\" ]; then RESOLVED=\".planning/${PLAN_ID}\"; SCOPE=\"scoped\"; elif [ -f .planning/.active_plan ]; then AP=$(tr -d '\\r\\n[:space:]' < .planning/.active_plan 2>/dev/null); if [ -n \"$AP\" ] && printf \"%s\" \"$AP\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${AP}\" ]; then RESOLVED=\".planning/${AP}\"; SCOPE=\"scoped\"; fi; fi; if [ -z \"$RESOLVED\" ] && [ -d .planning ]; then NEWEST=\"\"; NEWEST_MT=0; for d in .planning/*/; do d=\"${d%/}\"; n=$(basename \"$d\"); case \"$n\" in .*) continue;; esac; printf \"%s\" \"$n\" | grep -Eq \"$SLUG_RE\" || continue; [ -f \"$d/task_plan.md\" ] || continue; m=$(stat -c '%Y' \"$d\" 2>/dev/null || stat -f '%m' \"$d\" 2>/dev/null || date -r \"$d\" +%s 2>/dev/null || echo 0); if [ \"$m\" -gt \"$NEWEST_MT\" ] 2>/dev/null; then NEWEST_MT=\"$m\"; NEWEST=\"$d\"; fi; done; [ -n \"$NEWEST\" ] && { RESOLVED=\"$NEWEST\"; SCOPE=\"scoped\"; }; fi; if [ -z \"$RESOLVED\" ] && [ -f task_plan.md ]; then RESOLVED=\".\"; SCOPE=\"root\"; fi; [ -z \"$RESOLVED\" ] && exit 0; if [ \"$SCOPE\" = \"root\" ]; then PLAN_FILE=\"task_plan.md\"; PROGRESS_FILE=\"progress.md\"; ATTEST=\"\"; [ -f .plan-attestation ] && ATTEST=$(tr -d '\\r\\n[:space:]' < .plan-attestation 2>/dev/null); else PLAN_FILE=\"${RESOLVED}/task_plan.md\"; PROGRESS_FILE=\"${RESOLVED}/progress.md\"; ATTEST=\"\"; [ -f \"${RESOLVED}/.attestation\" ] && ATTEST=$(tr -d '\\r\\n[:space:]' < \"${RESOLVED}/.attestation\" 2>/dev/null); fi; [ -f \"$PLAN_FILE\" ] || exit 0; TAMPERED=0; ACTUAL=\"\"; if [ -n \"$ATTEST\" ]; then CD=\"${TMPDIR:-/tmp}/pwf-sha\"; mkdir -p \"$CD\" 2>/dev/null; KEY=$(printf \"%s\" \"$PLAN_FILE\" | { sha256sum 2>/dev/null || shasum -a 256 2>/dev/null; } | awk '{print $1}' | cut -c1-16); MT=$(stat -c '%Y' \"$PLAN_FILE\" 2>/dev/null || stat -f '%m' \"$PLAN_FILE\" 2>/dev/null || date -r \"$PLAN_FILE\" +%s 2>/dev/null || echo 0); CF=\"$CD/$KEY\"; CM=\"\"; CS=\"\"; if [ -f \"$CF\" ]; then CM=$(sed -n 1p \"$CF\" 2>/dev/null); CS=$(sed -n 2p \"$CF\" 2>/dev/null); fi; if [ -n \"$MT\" ] && [ \"$MT\" = \"$CM\" ] && [ -n \"$CS\" ]; then ACTUAL=\"$CS\"; else ACTUAL=$( (sha256sum \"$PLAN_FILE\" 2>/dev/null || shasum -a 256 \"$PLAN_FILE\" 2>/dev/null) | awk '{print $1}'); [ -n \"$ACTUAL\" ] && [ -n \"$MT\" ] && printf \"%s\\n%s\\n\" \"$MT\" \"$ACTUAL\" > \"$CF\" 2>/dev/null; fi; [ \"$ACTUAL\" != \"$ATTEST\" ] && TAMPERED=1; fi; echo '[planning-with-files] PreCompact: context compaction is about to occur.'; echo 'Before compaction completes: ensure progress.md captures recent actions and task_plan.md status reflects current phase.'; echo 'task_plan.md, findings.md, progress.md remain on disk and will be re-read after compaction.'; [ -n \"$ATTEST\" ] && echo \"Plan-SHA256 at compaction: $ATTEST\"; exit 0"
|
||||
metadata:
|
||||
version: "3.4.1"
|
||||
version: "3.5.0"
|
||||
|
||||
---
|
||||
|
||||
|
||||
+40
-1
@@ -1,5 +1,5 @@
|
||||
import { createHash } from "node:crypto";
|
||||
import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
|
||||
import { mkdirSync, mkdtempSync, rmSync, utimesSync, writeFileSync } from "node:fs";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
||||
@@ -88,6 +88,10 @@ function completePlan(): string {
|
||||
].join("\n");
|
||||
}
|
||||
|
||||
function closedIncompletePlan(): string {
|
||||
return incompletePlan() + "\n<!-- pwf: closed -->\n";
|
||||
}
|
||||
|
||||
function attestPlan(cwd: string, content: string): void {
|
||||
writeFileSync(join(cwd, ".planning", "demo", ".attestation"), sha256(content));
|
||||
}
|
||||
@@ -372,6 +376,41 @@ describe("Pi extension runtime handlers", () => {
|
||||
|
||||
expect(pi.sendMessage).toHaveBeenCalledTimes(2);
|
||||
});
|
||||
|
||||
it("agent_end sends no follow-up when the plan is closed even if incomplete", async () => {
|
||||
const cwd = makeWorkspace(closedIncompletePlan());
|
||||
const pi = loadExtension();
|
||||
const ctx = createContext(cwd);
|
||||
|
||||
await approvePlan(pi, ctx);
|
||||
await emit(pi, "agent_end", {}, ctx);
|
||||
|
||||
expect(pi.sendUserMessage).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("resolveNewestPlanDir ranks by task_plan.md file mtime, not directory mtime", async () => {
|
||||
const cwd = makeWorkspace(incompletePlan()); // creates .planning/demo (incomplete)
|
||||
const donePlanDir = join(cwd, ".planning", "done");
|
||||
mkdirSync(donePlanDir, { recursive: true });
|
||||
writeFileSync(join(donePlanDir, "task_plan.md"), completePlan());
|
||||
writeFileSync(join(donePlanDir, "progress.md"), "done\n");
|
||||
const older = new Date(Date.now() - 60_000);
|
||||
const newer = new Date();
|
||||
// done DIR older than demo DIR, but done's task_plan.md file NEWER than demo's
|
||||
utimesSync(donePlanDir, older, older);
|
||||
utimesSync(join(cwd, ".planning", "demo"), newer, newer);
|
||||
utimesSync(join(donePlanDir, "task_plan.md"), newer, newer);
|
||||
utimesSync(join(cwd, ".planning", "demo", "task_plan.md"), older, older);
|
||||
|
||||
const pi = loadExtension();
|
||||
const ctx = createContext(cwd);
|
||||
await emit(pi, "agent_end", {}, ctx);
|
||||
|
||||
expect(ctx.ui.notify).toHaveBeenCalledWith(
|
||||
"[planning-with-files] ALL PHASES COMPLETE (2/2).",
|
||||
"info",
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe("Pi extension runtime modes", () => {
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@tomxprime/planning-with-files-pi-extension",
|
||||
"version": "1.1.0",
|
||||
"version": "1.2.0",
|
||||
"private": true,
|
||||
"type": "module",
|
||||
"scripts": {
|
||||
|
||||
@@ -16,6 +16,7 @@ export interface PlanPaths {
|
||||
|
||||
export interface PlanStatus extends PlanPaths {
|
||||
exists: boolean;
|
||||
closed: boolean;
|
||||
totalPhases: number;
|
||||
completePhases: number;
|
||||
inProgressPhases: number;
|
||||
@@ -43,7 +44,8 @@ function resolveNewestPlanDir(planRoot: string): string | undefined {
|
||||
.map((dir) => {
|
||||
let mtime = 0;
|
||||
try {
|
||||
mtime = statSync(dir).mtimeMs;
|
||||
// Rank by task_plan.md mtime, not the directory: editing a plan's contents does not bump the dir mtime, which let a completed plan lose to a stale sibling (#203).
|
||||
mtime = statSync(join(dir, "task_plan.md")).mtimeMs;
|
||||
} catch {
|
||||
mtime = 0;
|
||||
}
|
||||
@@ -119,6 +121,7 @@ export function readPlanStatus(cwd: string): PlanStatus {
|
||||
return {
|
||||
...paths,
|
||||
exists: false,
|
||||
closed: false,
|
||||
totalPhases: 0,
|
||||
completePhases: 0,
|
||||
inProgressPhases: 0,
|
||||
@@ -130,6 +133,7 @@ export function readPlanStatus(cwd: string): PlanStatus {
|
||||
}
|
||||
|
||||
const planContent = safeRead(paths.planPath);
|
||||
const closed = /<!--\s*pwf:\s*closed\s*-->/i.test(planContent);
|
||||
const lines = planContent.split("\n");
|
||||
|
||||
const phaseRegex = /^###\s+Phase\b/i;
|
||||
@@ -164,6 +168,7 @@ export function readPlanStatus(cwd: string): PlanStatus {
|
||||
return {
|
||||
...paths,
|
||||
exists: true,
|
||||
closed,
|
||||
totalPhases: total,
|
||||
completePhases: complete,
|
||||
inProgressPhases: inProgress,
|
||||
|
||||
@@ -409,7 +409,7 @@ function registerCommands(pi: ExtensionAPI, state: RuntimeState): void {
|
||||
const status = readPlanStatus(ctx.cwd);
|
||||
if (!status.exists) return;
|
||||
|
||||
if (isAllPhasesComplete(status)) {
|
||||
if (isAllPhasesComplete(status) || status.closed) {
|
||||
const active = state.loopTimersBySession.get(sessionId);
|
||||
if (active) clearInterval(active);
|
||||
state.loopTimersBySession.delete(sessionId);
|
||||
@@ -607,6 +607,10 @@ export default function planningWithFilesExtension(pi: ExtensionAPI): void {
|
||||
|
||||
const sessionId = getSessionId(ctx);
|
||||
const planKey = getPlanSessionKey(ctx, status);
|
||||
if (status.closed) {
|
||||
state.autoContinueCountBySessionPlan.set(planKey, 0);
|
||||
return;
|
||||
}
|
||||
const mode = deriveEffectiveMode(resolveConfiguredMode(ctx.cwd), ctx);
|
||||
|
||||
if (isAllPhasesComplete(status)) {
|
||||
@@ -653,6 +657,12 @@ export default function planningWithFilesExtension(pi: ExtensionAPI): void {
|
||||
"Update progress.md with what was done, then read task_plan.md and continue remaining phases." +
|
||||
(goal ? ` Goal: ${goal}` : "");
|
||||
|
||||
if (process.env.PWF_DEBUG) {
|
||||
console.error(
|
||||
`[planning-with-files] agent_end nag: cwd=${ctx.cwd} planId=${status.planId ?? "root"} closed=${status.closed} phases=${status.completePhases}/${status.totalPhases}`,
|
||||
);
|
||||
}
|
||||
|
||||
pi.sendUserMessage(continueMessage, { deliverAs: "followUp" });
|
||||
});
|
||||
|
||||
|
||||
@@ -72,7 +72,9 @@ is_within_root() {
|
||||
root_real="$(canonicalize "${PWD}")" || root_real=""
|
||||
cand_real="$(canonicalize "${candidate}")" || cand_real=""
|
||||
if [ -z "${root_real}" ] || [ -z "${cand_real}" ]; then
|
||||
return 0
|
||||
# Slug validation blocks textual traversal, but only successful
|
||||
# canonicalization can rule out a symlink/junction escape.
|
||||
return 1
|
||||
fi
|
||||
case "${cand_real}" in
|
||||
"${root_real}"|"${root_real}"/*) return 0 ;;
|
||||
@@ -119,6 +121,12 @@ resolve_from_env() {
|
||||
resolve_from_active_file() {
|
||||
[ -f "${ACTIVE_FILE}" ] || return 1
|
||||
plan_id="$(tr -d '\r\n[:space:]' < "${ACTIVE_FILE}")"
|
||||
# UTF-8 BOM is not part of the plan id. POSIX printf octal escapes keep
|
||||
# this portable across GNU/BSD sed variants and Git-for-Windows sh.
|
||||
utf8_bom="$(printf '\357\273\277')"
|
||||
case "${plan_id}" in
|
||||
"${utf8_bom}"*) plan_id="${plan_id#"${utf8_bom}"}" ;;
|
||||
esac
|
||||
slug_is_valid "${plan_id}" || return 1
|
||||
candidate="${PLAN_ROOT}/${plan_id}"
|
||||
if [ -d "${candidate}" ] && is_within_root "${candidate}"; then
|
||||
|
||||
@@ -14,6 +14,30 @@ import os
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, Iterable, List, Optional, Tuple
|
||||
|
||||
|
||||
def configure_utf8_stdio() -> None:
|
||||
"""Make catchup output deterministic on Windows legacy code pages.
|
||||
|
||||
Codex sessions and planning files are UTF-8 and can contain arbitrary
|
||||
Unicode. Windows PowerShell may nevertheless launch Python with a cp1252
|
||||
(or another OEM/ANSI) stdout codec. A report containing Chinese text then
|
||||
used to fail at the first ``print`` with ``UnicodeEncodeError``. Configure
|
||||
both streams before any report is emitted; ``errors='replace'`` also keeps
|
||||
this advisory hook fail-safe if a malformed surrogate reaches the output.
|
||||
"""
|
||||
for stream in (sys.stdout, sys.stderr):
|
||||
reconfigure = getattr(stream, 'reconfigure', None)
|
||||
if callable(reconfigure):
|
||||
try:
|
||||
reconfigure(encoding='utf-8', errors='replace')
|
||||
except (OSError, ValueError):
|
||||
# Replaced/captured streams may not permit reconfiguration.
|
||||
# The hook remains advisory, so retain the existing stream.
|
||||
pass
|
||||
|
||||
|
||||
configure_utf8_stdio()
|
||||
|
||||
try:
|
||||
import orjson
|
||||
except ImportError:
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
# planning-with-files: set or display the active plan pointer (PowerShell).
|
||||
#
|
||||
# Usage:
|
||||
# .\set-active-plan.ps1 <plan_id> — pin .planning\.active_plan to plan_id
|
||||
# .\set-active-plan.ps1 — print the current active plan (if any)
|
||||
# .\set-active-plan.ps1 <plan_id> - pin .planning\.active_plan to plan_id
|
||||
# .\set-active-plan.ps1 - print the current active plan (if any)
|
||||
|
||||
param(
|
||||
[string]$PlanId = ""
|
||||
@@ -19,7 +19,7 @@ if ($PlanId -eq "") {
|
||||
Write-Output "Active plan: $current"
|
||||
Write-Output "Path: $planDir"
|
||||
} elseif ($current -ne "") {
|
||||
Write-Output "Active plan pointer: $current (directory not found — stale pointer)"
|
||||
Write-Output "Active plan pointer: $current (directory not found - stale pointer)"
|
||||
} else {
|
||||
Write-Output "No active plan set."
|
||||
}
|
||||
@@ -41,7 +41,8 @@ if (-not (Test-Path $PlanRoot)) {
|
||||
New-Item -ItemType Directory -Path $PlanRoot -Force | Out-Null
|
||||
}
|
||||
|
||||
Set-Content -Path $ActiveFile -Value $PlanId -Encoding UTF8 -NoNewline
|
||||
$utf8NoBom = New-Object System.Text.UTF8Encoding($false)
|
||||
[System.IO.File]::WriteAllText($ActiveFile, $PlanId, $utf8NoBom)
|
||||
|
||||
Write-Output "Active plan set to: $PlanId"
|
||||
Write-Output "Path: $PlanDir"
|
||||
|
||||
@@ -23,6 +23,34 @@ Infrastructure only. Nothing in the distributed skill changed, so no version bum
|
||||
|
||||
- @Yigtwxx (Yiğit) for filing the CI gap (#197) and landing both the test-portability fixes (#198) and the pytest plus vitest workflow (#199).
|
||||
|
||||
## [3.5.0] - 2026-07-13
|
||||
|
||||
### Fixed
|
||||
|
||||
- **Codex hooks on Windows emitted invalid JSON and failed on Unicode** (PR #205 by @yolo0731, closes #204). On Windows the Codex front door forwarded plain `[planning-with-files]` stdout where Codex expects `hookSpecificOutput.additionalContext` (SessionStart, UserPromptSubmit) or a common-fields object (PreCompact), so those hooks were rejected. UTF-8 plan text also broke twice, once decoding shell output through the Windows code page in `subprocess.run(text=True)` and again writing `ensure_ascii=False` JSON through cmd.exe. The fix serializes each event in its supported Codex JSON shape with ASCII-safe output, decodes shell output as UTF-8 with `errors="replace"`, routes PreToolUse plan text through model-visible `additionalContext`, resolves scoped `.planning/<slug>/` plans in PermissionRequest, adds `clear|compact` to the SessionStart matcher, and writes the `.active_plan` pointer as UTF-8 without a BOM. The containment resolver also now fails closed when canonicalization is unavailable. 34 files, with the three-file script triple applied identically across every adapter copy. Scope is Windows Codex, matching the report.
|
||||
|
||||
- **Closed and complete plans kept nagging "Task incomplete" in the Pi extension** (#203, reported by @ziyu4huang). `resolveNewestPlanDir` ranked plan directories by directory mtime, which does not change when a `task_plan.md`'s contents are edited, so a finished plan lost to an older incomplete sibling and `agent_end` nagged with that sibling's stale count. Resolution now ranks by the `task_plan.md` file mtime. The extension also had no close-marker awareness: `readPlanStatus` now parses the pwf close marker and exposes `status.closed`, `agent_end` returns early on a closed plan, and the auto-continue loop stops on close. A `PWF_DEBUG` diagnostic logs the resolved cwd, plan id, closed state, and phase count before the nag. Bundled Pi extension bumped to 1.2.0.
|
||||
|
||||
- **Four language commands invoked a skill namespace that does not exist.** `commands/plan-ar.md`, `plan-de.md`, `plan-es.md`, and `plan-zh.md` referenced `planning-with-files-<lang>:planning-with-files-<lang>`; the skills are registered under the single plugin namespace `planning-with-files:planning-with-files-<lang>`, which the English commands already used. Corrected all four.
|
||||
|
||||
### Added
|
||||
|
||||
- **Traditional Chinese slash command** (`commands/plan-zht.md`, `/plan-zht`). The `planning-with-files-zht` skill shipped without a matching command; this closes the ar/de/es/zh/zht command parity gap.
|
||||
|
||||
- **README now documents the full v3 command, hook, and mode surface.** The visible command table listed only three commands with v2.11.0 and v2.15.0 tags while the plugin ships `plan-goal`, `plan-loop`, `plan-attest`, `pwf`, and the language commands. Added visible sections for the Claude Code and Pi command tables, a v3 long-running-agent features section, a hooks-and-modes reference across Claude Code, Codex, and Pi, and a "command names vs skill names" note that states there is no `/pwf-de` or `/planning-with-files:planning-with-files-goal`. All additive.
|
||||
|
||||
- **Plan lifecycle is now documented** (#202, asked by @kcinzgg). `docs/workflow.md` gains an "After Completion" section stating that planning files are ephemeral working memory, gitignored by default, and not archived automatically, with guidance on retaining a completed plan and a note that a completion-triggered archive step is a welcome opt-in extension. Pointers added in `docs/quickstart.md` and the README FAQ. This writes down the intent that issue #14 answered informally.
|
||||
|
||||
### Security
|
||||
|
||||
- Independent supply-chain audit of PR #205 before merge (a classifier plus two adversarial containment passes, all clean): no new dependencies, no install scripts, no bin shims, no network calls, no eval of untrusted input. The one security-relevant change (containment moving from fail-open to fail-closed) is a hardening, covered by an added junction-escape rejection test.
|
||||
|
||||
### Thanks
|
||||
|
||||
- @yolo0731 for the Codex Windows hook fix (#204, PR #205), the protocol-safe JSON serialization and the UTF-8 handling.
|
||||
- @ziyu4huang for the precise #203 diagnosis, verified against the extension's own exported functions.
|
||||
- @kcinzgg for the #202 question that surfaced the undocumented plan lifecycle.
|
||||
|
||||
## [3.4.1] - 2026-07-12
|
||||
|
||||
### Fixed
|
||||
|
||||
+1
-1
@@ -7,7 +7,7 @@ authors:
|
||||
- family-names: Adi
|
||||
given-names: Ahmad Othman Ammar
|
||||
alias: OthmanAdi
|
||||
version: "3.4.1"
|
||||
version: "3.5.0"
|
||||
date-released: "2026-06-16"
|
||||
license: MIT
|
||||
url: "https://github.com/OthmanAdi/planning-with-files"
|
||||
|
||||
+14
-1
@@ -106,6 +106,19 @@ These amazing people have contributed code, documentation, or significant improv
|
||||
|
||||
### Other Contributors
|
||||
|
||||
- **[@yolo0731](https://github.com/yolo0731)** (yoloyq) - [PR #205](https://github.com/OthmanAdi/planning-with-files/pull/205), closes [Issue #204](https://github.com/OthmanAdi/planning-with-files/issues/204)
|
||||
- Fixed the Codex hooks on Windows emitting invalid JSON and failing on Unicode: plain `[planning-with-files]` stdout where Codex expects `hookSpecificOutput.additionalContext` or a common-fields object, UTF-8 shell output decoded through the Windows code page, and `ensure_ascii=False` JSON written through cmd.exe
|
||||
- Serialized each event in its supported Codex JSON shape with ASCII-safe output, decoded shell output as UTF-8, routed PreToolUse plan text through model-visible `additionalContext`, resolved scoped plans in PermissionRequest, added `clear|compact` SessionStart sources, wrote the `.active_plan` pointer without a BOM, and hardened the containment resolver to fail closed
|
||||
- **Impact:** v3.5.0 makes the full Codex hook surface work on Windows across active-plan, no-plan, disabled, malformed-input, and Unicode scenarios
|
||||
|
||||
- **[@ziyu4huang](https://github.com/ziyu4huang)** (Ziyu Huang) - [Issue #203](https://github.com/OthmanAdi/planning-with-files/issues/203)
|
||||
- Reported that a closed and complete plan kept emitting "Task incomplete" nags for many turns, with a root-cause trace against the Pi extension's own exported `resolvePlanPaths`, `readPlanStatus`, and `isPlanIncomplete`
|
||||
- **Impact:** v3.5.0 ranks newest-plan resolution by `task_plan.md` file mtime, adds close-marker awareness, and gates the nag on `status.closed`
|
||||
|
||||
- **[@kcinzgg](https://github.com/kcinzgg)** (Kcinzgg) - [Issue #202](https://github.com/OthmanAdi/planning-with-files/issues/202)
|
||||
- Asked for a direct statement of the plan-file lifecycle and why there is no archiving step, noting the earlier #14 had no visible resolution
|
||||
- **Impact:** v3.5.0 documents the ephemeral-working-memory lifecycle in `docs/workflow.md`, with pointers from `quickstart.md` and the README FAQ
|
||||
|
||||
- **[@mahdiit](https://github.com/mahdiit)** (Mahdi) - [Issue #201](https://github.com/OthmanAdi/planning-with-files/issues/201)
|
||||
- Reported that Codex hooks failed on Windows with `hook exited with code 1`: the `.codex/hooks.json` commands were POSIX only, so the Windows command interpreter choked on `python3` (the Store alias), `2>/dev/null`, and the `|| true` success guard whose `true` is not a Windows command
|
||||
- **Impact:** v3.4.1 adds per-hook `commandWindows` overrides, a `pwf-hook.cmd` launcher, a `run_sh.py` front door, and a git-bash resolver so all seven Codex hooks run on Windows
|
||||
@@ -358,4 +371,4 @@ If you've contributed and don't see your name here, please open an issue! We wan
|
||||
|
||||
**Total Contributors:** 50+ and growing!
|
||||
|
||||
*Last updated: July 8, 2026*
|
||||
*Last updated: July 13, 2026*
|
||||
|
||||
@@ -18,7 +18,7 @@
|
||||
|
||||
[](https://skillsplayground.com/skills/othmanadi-planning-with-files-planning-with-files/)
|
||||
[](https://skill-history.com/othmanadi/planning-with-files)
|
||||
[](https://github.com/OthmanAdi/planning-with-files/releases)
|
||||
[](https://github.com/OthmanAdi/planning-with-files/releases)
|
||||
[](https://opensource.org/licenses/MIT)
|
||||
[](https://github.com/OthmanAdi/planning-with-files/issues?q=is%3Aissue+is%3Aclosed)
|
||||
[](https://github.com/OthmanAdi/planning-with-files/pulls?q=is%3Apr+is%3Aclosed)
|
||||
@@ -78,6 +78,7 @@ See the full list of everyone who made this project better in [CONTRIBUTORS.md](
|
||||
|
||||
| Version | Highlights |
|
||||
|---------|------------|
|
||||
| **v3.5.0** | **Codex Windows hooks emit valid JSON and survive Unicode (PR #205 by @yolo0731, closes #204), the Pi extension stops re-nagging closed and complete plans (#203 by @ziyu4huang), and the plan lifecycle is documented (#202 by @kcinzgg).** On Windows the Codex front door forwarded plain stdout where Codex expects `hookSpecificOutput.additionalContext` or PreCompact JSON, and UTF-8 broke on both decode and encode; the fix serializes each event in its supported shape with ASCII-safe output, decodes shell output as UTF-8, and writes the `.active_plan` pointer without a BOM, with the containment resolver hardened to fail closed (audited clean before merge). The Pi `resolveNewestPlanDir` now ranks by `task_plan.md` file mtime instead of directory mtime and honors the close marker, so a finished plan no longer loses to an incomplete sibling. Four language commands that referenced a non-existent skill namespace were corrected, a Traditional Chinese `/plan-zht` command was added, and the README now documents the full v3 command, hook, and mode surface that had shipped but was never listed. |
|
||||
| **v3.4.1** | **Codex hooks now run on Windows (closes #201, reported by @mahdiit).** The `.codex/hooks.json` commands were POSIX only, so on Windows the native command interpreter choked on `python3` (the Store alias), `2>/dev/null`, and the `\|\| true` success guard whose `true` is not a Windows command, and every hook reported `hook exited with code 1`. Each hook now carries a per-hook `commandWindows` override (the POSIX `command` is untouched, so macOS and Linux are unchanged) that routes through a new `pwf-hook.cmd` launcher (real Python via `py -3`, falling back to `python`, never the Store `python3` alias) and, for the three shell hooks, a new `run_sh.py` front door. `codex_hook_adapter` resolves the Git for Windows `sh.exe` by anchoring on `git.exe`, so the shell scripts run even when Git's `usr\bin` is off PATH. Codex hook suites green (17 tests) plus new cross-platform and Windows-only coverage. |
|
||||
| **v3.4.0** | **`PLANNING_DISABLED=1` per-invocation opt-out for one-shot sessions (closes #195, reported by @marcmuon).** One-shot `codex exec` runs (CI review bots, read-only research agents, nested orchestrators) that merely shared a cwd with an incomplete plan were hijacked: plan context injected, the actual output redirected into `progress.md`, a fabricated completed phase appended to `task_plan.md`. All Codex hook entry points, the Python adapter route, and the canonical dispatchers (`inject-plan.sh`, `gate-stop.sh`, `check-complete.sh`/`.ps1`) now exit before reading the plan when `PLANNING_DISABLED=1` is set; PreToolUse keeps emitting its allow decision so tool calls proceed. The guard ships in every distributed copy including the five language variants. Also corrected `docs/codex.md`'s stale claim that the Stop hook blocks (non-blocking since v3.1.0). Suite at 200 passed. |
|
||||
| **v3.3.0** | **Pi extension hooks now wait for explicit user approval via `/plan-execute`** (PR #193 by @Dikshj, closes #190, requested by @lazyst). The Pi extension previously activated all hooks as soon as `task_plan.md` existed, so plan injection, pre-tool recitation, post-write reminders, and auto-continue could start while the user was still reviewing a draft plan. The extension now stays passive with a status line until the active plan is approved with `/plan-execute`; approval is scoped to the current session and plan path, resets on session lifecycle events, and `/plan-execute reset` returns to passive review. A plan with a tampered SHA-256 attestation cannot be approved. Suite at 188 passed plus 21 Pi extension vitest tests. |
|
||||
@@ -277,6 +278,13 @@ That's it! Now use one of these commands in Claude Code:
|
||||
| `/planning-with-files:plan` | Type `/plan` | Start planning session (v2.11.0+) |
|
||||
| `/planning-with-files:status` | Type `/plan:status` | Show planning progress at a glance (v2.15.0+) |
|
||||
| `/planning-with-files:start` | Type `/planning` | Original start command |
|
||||
| `/planning-with-files:pwf` | Type `/pwf` | Short alias for `/plan`; supports `--autonomous` / `--gated` init (v3.0.0+) |
|
||||
| `/planning-with-files:plan-goal` | Type `/plan-goal` | Run until the plan reports complete by composing with Claude Code `/goal` (v2.38.0+) |
|
||||
| `/planning-with-files:plan-loop` | Type `/plan-loop` | Planning-aware cadence on Claude Code `/loop`, default 10m tick (v2.38.0+) |
|
||||
| `/planning-with-files:plan-attest` | Type `/plan-attest` | Lock `task_plan.md` with a SHA-256 attestation; `--show` / `--clear` (v2.37.0+) |
|
||||
| `/planning-with-files:plan-de` | Type `/plan-de` | Start planning in German (also `-ar`, `-es`, `-zh`, `-zht`) (v2.33.0+) |
|
||||
|
||||
Typing `/plan` prefix-matches every `plan*` command in autocomplete; `/planning-with-files:status` autocompletes as `/status` (the older `/plan:status` label predates the rename). On the Pi extension the status command is named `plan-status`.
|
||||
|
||||
**Alternative:** If you want `/planning-with-files` (without prefix), copy skills to your local folder:
|
||||
|
||||
@@ -292,6 +300,24 @@ Copy-Item -Recurse -Path "$env:USERPROFILE\.claude\plugins\cache\planning-with-f
|
||||
|
||||
See [docs/installation.md](docs/installation.md) for all installation methods.
|
||||
|
||||
### Pi extension commands
|
||||
|
||||
Install the Pi extension with `pi install npm:@tomxprime/planning-with-files`; it registers these commands, and on Pi they are typed with no `/planning-with-files:` prefix.
|
||||
|
||||
| Command | What it does | Version |
|
||||
|---------|--------------|---------|
|
||||
| `/plan-execute` | Pi only. Approve the active plan to ACTIVATE all Pi hooks; hooks stay passive until you run this; `reset` returns to passive review | v3.3.0+ |
|
||||
| `/plan-status` | Active plan path, scope, and phase totals | v2.39.0+ |
|
||||
| `/plan-goal <text\|default\|clear>` | Set or clear the goal string appended to auto-continue prompts | v2.39.0+ |
|
||||
| `/plan-loop [interval] [prompt\|stop]` | Start or stop a planning tick (default 10m) that re-reads the plan and nudges progress | v2.39.0+ |
|
||||
| `/plan-attest [--show\|--clear]` | Run the attest-plan helper; shares the `.attestation` file with Claude Code | v2.39.0+ |
|
||||
|
||||
On Pi there is no `/plan` command to create the files; the skill creates them, then `/plan-execute` approves and activates the hooks. Note that Pi `plan-goal`/`plan-loop` run their own logic, while the Claude Code commands of the same name forward to native `/goal` and `/loop`.
|
||||
|
||||
### Command names vs skill names
|
||||
|
||||
The command you TYPE differs by platform. Claude Code uses `/planning-with-files:<verb>` (for example `/plan`, `/plan-de`, `/plan-goal`, `/plan-attest`, `/pwf`, `/status`). Pi uses the bare form (`/plan-status`, `/plan-execute`, `/plan-goal`, `/plan-loop`, `/plan-attest`), no prefix. Continue.dev uses `/planning-with-files`. The underlying model-invocable SKILLS are named `planning-with-files:planning-with-files` (and `-de`, `-es`, `-ar`, `-zh`, `-zht`); that doubled form is the skill id, not a command you type. There is no `/pwf-de` and no `/planning-with-files:planning-with-files-goal`; `/pwf` is just a short alias for `/plan`.
|
||||
|
||||
## Why This Skill?
|
||||
|
||||
On December 29, 2025, [Meta acquired Manus for $2 billion](https://techcrunch.com/2025/12/29/meta-just-bought-manus-an-ai-startup-everyone-has-been-talking-about/). In just 8 months, Manus went from launch to $100M+ revenue. Their secret? **Context engineering**.
|
||||
@@ -351,11 +377,46 @@ Once installed, the AI agent will:
|
||||
|
||||
Invoke with:
|
||||
- `/planning-with-files:plan` - Type `/plan` to find in autocomplete (v2.11.0+)
|
||||
- `/planning-with-files:pwf` - Type `/pwf`, short alias for `/plan` (v3.0.0+)
|
||||
- `/planning-with-files:start` - Type `/planning` to find in autocomplete
|
||||
- `/planning-with-files` - Only if you copied skills to `~/.claude/skills/`
|
||||
|
||||
For the goal, loop, attest, language, and Pi commands, see the command tables above.
|
||||
|
||||
See [docs/quickstart.md](docs/quickstart.md) for the full 5-step guide.
|
||||
|
||||
## v3 Long-Running Agent Features
|
||||
|
||||
The v3 line adds features aimed at long-running agentic runs. Each one is listed with the command or flag that turns it on. With no mode marker set, the hooks produce the same output as v2.43, so nothing changes for existing setups.
|
||||
|
||||
- **Autonomous mode** (`/pwf --autonomous`, or `init-session.sh --autonomous`): drops the per-tool-call plan recitation, keeps the turn-start injection, and turns attestation on by default.
|
||||
- **Gated mode** (`--gated`): adds a Stop completion gate that blocks only when all completion conditions hold at once, so an incomplete plan alone never traps a session.
|
||||
- **Auto-continue on Pi** (`agent_end` handler): re-prompts the agent up to a limit of 3 to keep an unfinished plan moving, plus an optional `/plan-goal` string appended to the prompt.
|
||||
- **Pi approval gate** (`/plan-execute`): Pi hooks stay passive with a status line until you approve the active plan for the current session.
|
||||
- **Session-catchup**: resumes work after `/clear` by re-reading the planning files from the active IDE's session store.
|
||||
- **PreCompact progress flush** (`PreCompact` hook): surfaces a reminder to flush progress before compaction completes, and prints the active Plan-SHA256 when attested.
|
||||
- **SHA-256 plan attestation** (`/plan-attest`): locks `task_plan.md`; a tampered plan body is refused at injection.
|
||||
- **Run ledger**: an append-only JSONL record of phase transitions that replaces the raw `progress.md` tail in v3 modes with a fixed-shape summary.
|
||||
- **Host capability tiers**: hard block on Claude Code, Codex, and Continue; follow-up injection on Cursor, Pi, and Kiro; notify-only elsewhere.
|
||||
- **Per-invocation opt-out** (`PLANNING_DISABLED=1`, v3.4.0): a one-shot session that merely shares a cwd with an incomplete plan skips all plan reading at every hook entry point.
|
||||
|
||||
### Hooks and modes reference
|
||||
|
||||
| Platform | Lifecycle hooks | Where registered |
|
||||
|----------|-----------------|------------------|
|
||||
| Claude Code | 5: UserPromptSubmit, PreToolUse, PostToolUse, Stop, PreCompact | The skill's `SKILL.md` frontmatter (not `plugin.json`), so they ship with the bundled skill |
|
||||
| Codex CLI | 7: SessionStart, UserPromptSubmit, PreToolUse, PermissionRequest, PostToolUse, PreCompact, Stop | `.codex/hooks.json`, Windows-safe via `commandWindows` since v3.4.1 |
|
||||
| Pi | 8 lifecycle handlers in the bundled extension | The injection and recitation handlers stay passive until `/plan-execute` |
|
||||
|
||||
Pi runtime modes:
|
||||
|
||||
| Pi mode | Behavior |
|
||||
|---------|----------|
|
||||
| `auto` | Detects the model and picks `parity` or `cache-safe` |
|
||||
| `parity` | Full plan injection, mirrors the Claude Code skill |
|
||||
| `cache-safe` | A stable reminder instead of full injection, for KV-cache-sensitive models like DeepSeek |
|
||||
| `notify` | Status-line only, no model injection |
|
||||
|
||||
## Benchmark Results
|
||||
|
||||
> **Methodology note:** the 96.7% figure comes from the v2.21.0 evaluation run on `claude-sonnet-4-6` (2026-03-06). It measures file-pattern fidelity (does the agent create and maintain the 3-file structure), not goal-drift over long autonomous runs. Newer models and the autonomous-mode work are not yet covered by this number. Full methodology, dataset, and assertion list: [docs/evals.md](docs/evals.md).
|
||||
@@ -397,9 +458,16 @@ Formally evaluated using Anthropic's [skill-creator](https://github.com/anthropi
|
||||
planning-with-files/
|
||||
├── commands/ # Plugin commands
|
||||
│ ├── plan.md # /planning-with-files:plan command (v2.11.0+)
|
||||
│ ├── pwf.md # /planning-with-files:pwf short alias for /plan (v3.0.0+)
|
||||
│ ├── status.md # /planning-with-files:status progress view (v2.15.0+)
|
||||
│ ├── plan-goal.md # /planning-with-files:plan-goal, composes with /goal (v2.38.0+)
|
||||
│ ├── plan-loop.md # /planning-with-files:plan-loop, composes with /loop (v2.38.0+)
|
||||
│ ├── plan-attest.md # /planning-with-files:plan-attest SHA-256 lock (v2.37.0+)
|
||||
│ ├── plan-ar.md # Arabic /plan command (v2.33.0+)
|
||||
│ ├── plan-de.md # German /plan command (v2.33.0+)
|
||||
│ ├── plan-es.md # Spanish /plan command (v2.33.0+)
|
||||
│ ├── plan-zh.md # Chinese Simplified /plan command (v2.33.0+)
|
||||
│ ├── plan-zht.md # Chinese Traditional /plan command (v2.33.0+)
|
||||
│ └── start.md # /planning-with-files:start command
|
||||
├── templates/ # Root-level templates (for CLAUDE_PLUGIN_ROOT)
|
||||
├── scripts/ # Root-level scripts (for CLAUDE_PLUGIN_ROOT)
|
||||
@@ -505,6 +573,10 @@ Context rot is the drift that sets in as the context window fills and earlier in
|
||||
|
||||
Claude Code, OpenAI Codex CLI, Cursor, GitHub Copilot, Kiro, OpenCode, Continue, Pi, CodeBuddy, Factory, Mastra, and 60+ others via the SKILL.md open standard. Installation is one command; see [Quick Install](#quick-install) above.
|
||||
|
||||
### What happens to the plan files after a task is complete?
|
||||
|
||||
They are working memory, not a tracked deliverable. `task_plan.md`, `findings.md`, `progress.md`, and the `.planning/` directory are gitignored by default and are not archived automatically: the next task overwrites the root plan, and a slug directory just stops being active. Anything worth keeping should be promoted into code, a commit, or a doc. See [After Completion: What Happens to the Plan Files](docs/workflow.md#after-completion-what-happens-to-the-plan-files) for the full lifecycle and how to retain a completed plan. This is a deliberate default, not a missing feature; a completion-triggered archive step is a welcome opt-in extension.
|
||||
|
||||
## Documentation
|
||||
|
||||
All platform setup guides and documentation are in the [docs/](./docs/) folder.
|
||||
|
||||
+1
-1
@@ -2,7 +2,7 @@
|
||||
description: "بدء تخطيط الملفات بنمط Manus. إنشاء task_plan.md و findings.md و progress.md للمهام المعقدة."
|
||||
---
|
||||
|
||||
استدعاء مهارة planning-with-files-ar:planning-with-files-ar وتنفيذ التعليمات بدقة.
|
||||
استدعاء مهارة planning-with-files:planning-with-files-ar وتنفيذ التعليمات بدقة.
|
||||
|
||||
إذا لم تكن ملفات التخطيط الثلاثة موجودة في مجلد المشروع الحالي، قم بإنشائها:
|
||||
- task_plan.md — للمراحل والتقدم والقرارات
|
||||
|
||||
+1
-1
@@ -2,7 +2,7 @@
|
||||
description: "Starte Manus-artige Dateiplanung. Erstelle task_plan.md, findings.md, progress.md für komplexe Aufgaben."
|
||||
---
|
||||
|
||||
Rufe die planning-with-files-de:planning-with-files-de Skill auf und folge den Anweisungen genau.
|
||||
Rufe die planning-with-files:planning-with-files-de Skill auf und folge den Anweisungen genau.
|
||||
|
||||
Wenn die drei Planungsdateien nicht im aktuellen Projektverzeichnis existieren, erstelle sie:
|
||||
- task_plan.md — für Phasen, Fortschritt und Entscheidungen
|
||||
|
||||
+1
-1
@@ -2,7 +2,7 @@
|
||||
description: "Iniciar planificación de archivos estilo Manus. Crear task_plan.md, findings.md, progress.md para tareas complejas."
|
||||
---
|
||||
|
||||
Invocar la habilidad planning-with-files-es:planning-with-files-es y ejecutar sus instrucciones estrictamente.
|
||||
Invocar la habilidad planning-with-files:planning-with-files-es y ejecutar sus instrucciones estrictamente.
|
||||
|
||||
Si los tres archivos de planificación no existen en el directorio del proyecto actual, créalos:
|
||||
- task_plan.md — para fases, progreso y decisiones
|
||||
|
||||
+1
-1
@@ -2,7 +2,7 @@
|
||||
description: "启动 Manus 风格的文件规划。为复杂任务创建 task_plan.md、findings.md、progress.md。"
|
||||
---
|
||||
|
||||
调用 planning-with-files-zh:planning-with-files-zh 技能,并严格按照其指示执行。
|
||||
调用 planning-with-files:planning-with-files-zh 技能,并严格按照其指示执行。
|
||||
|
||||
如果当前项目目录中不存在以下三个规划文件,请创建它们:
|
||||
- task_plan.md — 用于阶段、进度和决策
|
||||
|
||||
@@ -0,0 +1,12 @@
|
||||
---
|
||||
description: "啟動 Manus 風格的檔案規劃。為複雜任務建立 task_plan.md、findings.md、progress.md。"
|
||||
---
|
||||
|
||||
調用 planning-with-files:planning-with-files-zht 技能,並嚴格按照其指示執行。
|
||||
|
||||
如果當前專案目錄中不存在以下三個規劃檔案,請建立它們:
|
||||
- task_plan.md — 用於階段、進度和決策
|
||||
- findings.md — 用於研究和發現
|
||||
- progress.md — 用於工作階段日誌
|
||||
|
||||
然後引導使用者完成規劃工作流程。所有規劃檔案內容使用繁體中文。
|
||||
@@ -140,6 +140,8 @@ remaining risks, and rollback notes in the topic handoff.
|
||||
|
||||
**If complete:** Deliver your work! All three planning files document your process.
|
||||
|
||||
The planning files are working memory, not a tracked deliverable: they are gitignored and are not archived automatically. See [After Completion: What Happens to the Plan Files](workflow.md#after-completion-what-happens-to-the-plan-files) for the intended lifecycle and how to keep a completed plan if you want one.
|
||||
|
||||
---
|
||||
|
||||
## Quick Reference: When to Update Which File
|
||||
|
||||
@@ -112,6 +112,22 @@ This diagram shows how the three files work together and how hooks interact with
|
||||
|
||||
---
|
||||
|
||||
## After Completion: What Happens to the Plan Files
|
||||
|
||||
The planning files are working memory for one task, not a deliverable. `task_plan.md`, `findings.md`, `progress.md`, and any `.planning/<slug>/` directory are gitignored by default, and nothing archives them when a task finishes. In root mode the next task overwrites `task_plan.md`; in slug mode the old directory just stops being the active plan. There is no automatic "completed" or "archived" state, and `check-complete` reports completion without moving or extracting anything.
|
||||
|
||||
The behavior is consistent and intentional, though it was never stated as a rule until now (see [#14](https://github.com/OthmanAdi/planning-with-files/issues/14) and [#202](https://github.com/OthmanAdi/planning-with-files/issues/202)). The model is the Manus one the skill is built on: the context window is RAM and the filesystem is disk, so work survives `/clear` and a crash *during* a task. Anything meant to outlive the task belongs somewhere durable already, in code, in a commit, in a spec or doc, or in a `findings.md` you deliberately keep out of the gitignore.
|
||||
|
||||
If you want a completed plan to persist, keep it yourself:
|
||||
|
||||
- Copy the decisions and errors you care about into code comments, a commit message, an ADR, or a `docs/` note.
|
||||
- Move the `.planning/<slug>/` directory outside the ignored path, or drop `.planning/` from `.gitignore` in a repo where you want plans tracked.
|
||||
- For personal reuse, keep the directory as a cache for a future related task and pin it with `PLAN_ID` or `.active_plan`.
|
||||
|
||||
A completion-triggered archive step (move `.planning/<slug>/` into an archive directory and extract the decisions and errors tables into a git-tracked record) is a reasonable opt-in extension. It would sit on top of the three-file default the way attestation, gated mode, and topic handoffs already do, without changing the ephemeral default. It is not built in today. If you want it, a focused issue or PR is welcome.
|
||||
|
||||
---
|
||||
|
||||
## Key Interactions
|
||||
|
||||
### Hooks
|
||||
|
||||
@@ -72,7 +72,9 @@ is_within_root() {
|
||||
root_real="$(canonicalize "${PWD}")" || root_real=""
|
||||
cand_real="$(canonicalize "${candidate}")" || cand_real=""
|
||||
if [ -z "${root_real}" ] || [ -z "${cand_real}" ]; then
|
||||
return 0
|
||||
# Slug validation blocks textual traversal, but only successful
|
||||
# canonicalization can rule out a symlink/junction escape.
|
||||
return 1
|
||||
fi
|
||||
case "${cand_real}" in
|
||||
"${root_real}"|"${root_real}"/*) return 0 ;;
|
||||
@@ -119,6 +121,12 @@ resolve_from_env() {
|
||||
resolve_from_active_file() {
|
||||
[ -f "${ACTIVE_FILE}" ] || return 1
|
||||
plan_id="$(tr -d '\r\n[:space:]' < "${ACTIVE_FILE}")"
|
||||
# UTF-8 BOM is not part of the plan id. POSIX printf octal escapes keep
|
||||
# this portable across GNU/BSD sed variants and Git-for-Windows sh.
|
||||
utf8_bom="$(printf '\357\273\277')"
|
||||
case "${plan_id}" in
|
||||
"${utf8_bom}"*) plan_id="${plan_id#"${utf8_bom}"}" ;;
|
||||
esac
|
||||
slug_is_valid "${plan_id}" || return 1
|
||||
candidate="${PLAN_ROOT}/${plan_id}"
|
||||
if [ -d "${candidate}" ] && is_within_root "${candidate}"; then
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
# planning-with-files: set or display the active plan pointer (PowerShell).
|
||||
#
|
||||
# Usage:
|
||||
# .\set-active-plan.ps1 <plan_id> — pin .planning\.active_plan to plan_id
|
||||
# .\set-active-plan.ps1 — print the current active plan (if any)
|
||||
# .\set-active-plan.ps1 <plan_id> - pin .planning\.active_plan to plan_id
|
||||
# .\set-active-plan.ps1 - print the current active plan (if any)
|
||||
|
||||
param(
|
||||
[string]$PlanId = ""
|
||||
@@ -19,7 +19,7 @@ if ($PlanId -eq "") {
|
||||
Write-Output "Active plan: $current"
|
||||
Write-Output "Path: $planDir"
|
||||
} elseif ($current -ne "") {
|
||||
Write-Output "Active plan pointer: $current (directory not found — stale pointer)"
|
||||
Write-Output "Active plan pointer: $current (directory not found - stale pointer)"
|
||||
} else {
|
||||
Write-Output "No active plan set."
|
||||
}
|
||||
@@ -41,7 +41,8 @@ if (-not (Test-Path $PlanRoot)) {
|
||||
New-Item -ItemType Directory -Path $PlanRoot -Force | Out-Null
|
||||
}
|
||||
|
||||
Set-Content -Path $ActiveFile -Value $PlanId -Encoding UTF8 -NoNewline
|
||||
$utf8NoBom = New-Object System.Text.UTF8Encoding($false)
|
||||
[System.IO.File]::WriteAllText($ActiveFile, $PlanId, $utf8NoBom)
|
||||
|
||||
Write-Output "Active plan set to: $PlanId"
|
||||
Write-Output "Path: $PlanDir"
|
||||
|
||||
@@ -28,7 +28,7 @@ hooks:
|
||||
- type: command
|
||||
command: "RESOLVED=\"\"; SCOPE=\"\"; SLUG_RE='^[A-Za-z0-9_][A-Za-z0-9._-]*$'; if [ -n \"${PLAN_ID:-}\" ] && printf \"%s\" \"$PLAN_ID\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${PLAN_ID}\" ]; then RESOLVED=\".planning/${PLAN_ID}\"; SCOPE=\"scoped\"; elif [ -f .planning/.active_plan ]; then AP=$(tr -d '\\r\\n[:space:]' < .planning/.active_plan 2>/dev/null); if [ -n \"$AP\" ] && printf \"%s\" \"$AP\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${AP}\" ]; then RESOLVED=\".planning/${AP}\"; SCOPE=\"scoped\"; fi; fi; if [ -z \"$RESOLVED\" ] && [ -d .planning ]; then NEWEST=\"\"; NEWEST_MT=0; for d in .planning/*/; do d=\"${d%/}\"; n=$(basename \"$d\"); case \"$n\" in .*) continue;; esac; printf \"%s\" \"$n\" | grep -Eq \"$SLUG_RE\" || continue; [ -f \"$d/task_plan.md\" ] || continue; m=$(stat -c '%Y' \"$d\" 2>/dev/null || stat -f '%m' \"$d\" 2>/dev/null || date -r \"$d\" +%s 2>/dev/null || echo 0); if [ \"$m\" -gt \"$NEWEST_MT\" ] 2>/dev/null; then NEWEST_MT=\"$m\"; NEWEST=\"$d\"; fi; done; [ -n \"$NEWEST\" ] && { RESOLVED=\"$NEWEST\"; SCOPE=\"scoped\"; }; fi; if [ -z \"$RESOLVED\" ] && [ -f task_plan.md ]; then RESOLVED=\".\"; SCOPE=\"root\"; fi; [ -z \"$RESOLVED\" ] && exit 0; if [ \"$SCOPE\" = \"root\" ]; then PLAN_FILE=\"task_plan.md\"; PROGRESS_FILE=\"progress.md\"; ATTEST=\"\"; [ -f .plan-attestation ] && ATTEST=$(tr -d '\\r\\n[:space:]' < .plan-attestation 2>/dev/null); else PLAN_FILE=\"${RESOLVED}/task_plan.md\"; PROGRESS_FILE=\"${RESOLVED}/progress.md\"; ATTEST=\"\"; [ -f \"${RESOLVED}/.attestation\" ] && ATTEST=$(tr -d '\\r\\n[:space:]' < \"${RESOLVED}/.attestation\" 2>/dev/null); fi; [ -f \"$PLAN_FILE\" ] || exit 0; TAMPERED=0; ACTUAL=\"\"; if [ -n \"$ATTEST\" ]; then CD=\"${TMPDIR:-/tmp}/pwf-sha\"; mkdir -p \"$CD\" 2>/dev/null; KEY=$(printf \"%s\" \"$PLAN_FILE\" | { sha256sum 2>/dev/null || shasum -a 256 2>/dev/null; } | awk '{print $1}' | cut -c1-16); MT=$(stat -c '%Y' \"$PLAN_FILE\" 2>/dev/null || stat -f '%m' \"$PLAN_FILE\" 2>/dev/null || date -r \"$PLAN_FILE\" +%s 2>/dev/null || echo 0); CF=\"$CD/$KEY\"; CM=\"\"; CS=\"\"; if [ -f \"$CF\" ]; then CM=$(sed -n 1p \"$CF\" 2>/dev/null); CS=$(sed -n 2p \"$CF\" 2>/dev/null); fi; if [ -n \"$MT\" ] && [ \"$MT\" = \"$CM\" ] && [ -n \"$CS\" ]; then ACTUAL=\"$CS\"; else ACTUAL=$( (sha256sum \"$PLAN_FILE\" 2>/dev/null || shasum -a 256 \"$PLAN_FILE\" 2>/dev/null) | awk '{print $1}'); [ -n \"$ACTUAL\" ] && [ -n \"$MT\" ] && printf \"%s\\n%s\\n\" \"$MT\" \"$ACTUAL\" > \"$CF\" 2>/dev/null; fi; [ \"$ACTUAL\" != \"$ATTEST\" ] && TAMPERED=1; fi; echo '[planning-with-files] PreCompact: context compaction is about to occur.'; echo 'Before compaction completes: ensure progress.md captures recent actions and task_plan.md status reflects current phase.'; echo 'task_plan.md, findings.md, progress.md remain on disk and will be re-read after compaction.'; [ -n \"$ATTEST\" ] && echo \"Plan-SHA256 at compaction: $ATTEST\"; exit 0"
|
||||
metadata:
|
||||
version: "3.4.1"
|
||||
version: "3.5.0"
|
||||
---
|
||||
|
||||
# نظام تخطيط الملفات
|
||||
|
||||
@@ -28,7 +28,7 @@ hooks:
|
||||
- type: command
|
||||
command: "RESOLVED=\"\"; SCOPE=\"\"; SLUG_RE='^[A-Za-z0-9_][A-Za-z0-9._-]*$'; if [ -n \"${PLAN_ID:-}\" ] && printf \"%s\" \"$PLAN_ID\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${PLAN_ID}\" ]; then RESOLVED=\".planning/${PLAN_ID}\"; SCOPE=\"scoped\"; elif [ -f .planning/.active_plan ]; then AP=$(tr -d '\\r\\n[:space:]' < .planning/.active_plan 2>/dev/null); if [ -n \"$AP\" ] && printf \"%s\" \"$AP\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${AP}\" ]; then RESOLVED=\".planning/${AP}\"; SCOPE=\"scoped\"; fi; fi; if [ -z \"$RESOLVED\" ] && [ -d .planning ]; then NEWEST=\"\"; NEWEST_MT=0; for d in .planning/*/; do d=\"${d%/}\"; n=$(basename \"$d\"); case \"$n\" in .*) continue;; esac; printf \"%s\" \"$n\" | grep -Eq \"$SLUG_RE\" || continue; [ -f \"$d/task_plan.md\" ] || continue; m=$(stat -c '%Y' \"$d\" 2>/dev/null || stat -f '%m' \"$d\" 2>/dev/null || date -r \"$d\" +%s 2>/dev/null || echo 0); if [ \"$m\" -gt \"$NEWEST_MT\" ] 2>/dev/null; then NEWEST_MT=\"$m\"; NEWEST=\"$d\"; fi; done; [ -n \"$NEWEST\" ] && { RESOLVED=\"$NEWEST\"; SCOPE=\"scoped\"; }; fi; if [ -z \"$RESOLVED\" ] && [ -f task_plan.md ]; then RESOLVED=\".\"; SCOPE=\"root\"; fi; [ -z \"$RESOLVED\" ] && exit 0; if [ \"$SCOPE\" = \"root\" ]; then PLAN_FILE=\"task_plan.md\"; PROGRESS_FILE=\"progress.md\"; ATTEST=\"\"; [ -f .plan-attestation ] && ATTEST=$(tr -d '\\r\\n[:space:]' < .plan-attestation 2>/dev/null); else PLAN_FILE=\"${RESOLVED}/task_plan.md\"; PROGRESS_FILE=\"${RESOLVED}/progress.md\"; ATTEST=\"\"; [ -f \"${RESOLVED}/.attestation\" ] && ATTEST=$(tr -d '\\r\\n[:space:]' < \"${RESOLVED}/.attestation\" 2>/dev/null); fi; [ -f \"$PLAN_FILE\" ] || exit 0; TAMPERED=0; ACTUAL=\"\"; if [ -n \"$ATTEST\" ]; then CD=\"${TMPDIR:-/tmp}/pwf-sha\"; mkdir -p \"$CD\" 2>/dev/null; KEY=$(printf \"%s\" \"$PLAN_FILE\" | { sha256sum 2>/dev/null || shasum -a 256 2>/dev/null; } | awk '{print $1}' | cut -c1-16); MT=$(stat -c '%Y' \"$PLAN_FILE\" 2>/dev/null || stat -f '%m' \"$PLAN_FILE\" 2>/dev/null || date -r \"$PLAN_FILE\" +%s 2>/dev/null || echo 0); CF=\"$CD/$KEY\"; CM=\"\"; CS=\"\"; if [ -f \"$CF\" ]; then CM=$(sed -n 1p \"$CF\" 2>/dev/null); CS=$(sed -n 2p \"$CF\" 2>/dev/null); fi; if [ -n \"$MT\" ] && [ \"$MT\" = \"$CM\" ] && [ -n \"$CS\" ]; then ACTUAL=\"$CS\"; else ACTUAL=$( (sha256sum \"$PLAN_FILE\" 2>/dev/null || shasum -a 256 \"$PLAN_FILE\" 2>/dev/null) | awk '{print $1}'); [ -n \"$ACTUAL\" ] && [ -n \"$MT\" ] && printf \"%s\\n%s\\n\" \"$MT\" \"$ACTUAL\" > \"$CF\" 2>/dev/null; fi; [ \"$ACTUAL\" != \"$ATTEST\" ] && TAMPERED=1; fi; echo '[planning-with-files] PreCompact: context compaction is about to occur.'; echo 'Before compaction completes: ensure progress.md captures recent actions and task_plan.md status reflects current phase.'; echo 'task_plan.md, findings.md, progress.md remain on disk and will be re-read after compaction.'; [ -n \"$ATTEST\" ] && echo \"Plan-SHA256 at compaction: $ATTEST\"; exit 0"
|
||||
metadata:
|
||||
version: "3.4.1"
|
||||
version: "3.5.0"
|
||||
---
|
||||
|
||||
# Dateiplanungssystem
|
||||
|
||||
@@ -28,7 +28,7 @@ hooks:
|
||||
- type: command
|
||||
command: "RESOLVED=\"\"; SCOPE=\"\"; SLUG_RE='^[A-Za-z0-9_][A-Za-z0-9._-]*$'; if [ -n \"${PLAN_ID:-}\" ] && printf \"%s\" \"$PLAN_ID\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${PLAN_ID}\" ]; then RESOLVED=\".planning/${PLAN_ID}\"; SCOPE=\"scoped\"; elif [ -f .planning/.active_plan ]; then AP=$(tr -d '\\r\\n[:space:]' < .planning/.active_plan 2>/dev/null); if [ -n \"$AP\" ] && printf \"%s\" \"$AP\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${AP}\" ]; then RESOLVED=\".planning/${AP}\"; SCOPE=\"scoped\"; fi; fi; if [ -z \"$RESOLVED\" ] && [ -d .planning ]; then NEWEST=\"\"; NEWEST_MT=0; for d in .planning/*/; do d=\"${d%/}\"; n=$(basename \"$d\"); case \"$n\" in .*) continue;; esac; printf \"%s\" \"$n\" | grep -Eq \"$SLUG_RE\" || continue; [ -f \"$d/task_plan.md\" ] || continue; m=$(stat -c '%Y' \"$d\" 2>/dev/null || stat -f '%m' \"$d\" 2>/dev/null || date -r \"$d\" +%s 2>/dev/null || echo 0); if [ \"$m\" -gt \"$NEWEST_MT\" ] 2>/dev/null; then NEWEST_MT=\"$m\"; NEWEST=\"$d\"; fi; done; [ -n \"$NEWEST\" ] && { RESOLVED=\"$NEWEST\"; SCOPE=\"scoped\"; }; fi; if [ -z \"$RESOLVED\" ] && [ -f task_plan.md ]; then RESOLVED=\".\"; SCOPE=\"root\"; fi; [ -z \"$RESOLVED\" ] && exit 0; if [ \"$SCOPE\" = \"root\" ]; then PLAN_FILE=\"task_plan.md\"; PROGRESS_FILE=\"progress.md\"; ATTEST=\"\"; [ -f .plan-attestation ] && ATTEST=$(tr -d '\\r\\n[:space:]' < .plan-attestation 2>/dev/null); else PLAN_FILE=\"${RESOLVED}/task_plan.md\"; PROGRESS_FILE=\"${RESOLVED}/progress.md\"; ATTEST=\"\"; [ -f \"${RESOLVED}/.attestation\" ] && ATTEST=$(tr -d '\\r\\n[:space:]' < \"${RESOLVED}/.attestation\" 2>/dev/null); fi; [ -f \"$PLAN_FILE\" ] || exit 0; TAMPERED=0; ACTUAL=\"\"; if [ -n \"$ATTEST\" ]; then CD=\"${TMPDIR:-/tmp}/pwf-sha\"; mkdir -p \"$CD\" 2>/dev/null; KEY=$(printf \"%s\" \"$PLAN_FILE\" | { sha256sum 2>/dev/null || shasum -a 256 2>/dev/null; } | awk '{print $1}' | cut -c1-16); MT=$(stat -c '%Y' \"$PLAN_FILE\" 2>/dev/null || stat -f '%m' \"$PLAN_FILE\" 2>/dev/null || date -r \"$PLAN_FILE\" +%s 2>/dev/null || echo 0); CF=\"$CD/$KEY\"; CM=\"\"; CS=\"\"; if [ -f \"$CF\" ]; then CM=$(sed -n 1p \"$CF\" 2>/dev/null); CS=$(sed -n 2p \"$CF\" 2>/dev/null); fi; if [ -n \"$MT\" ] && [ \"$MT\" = \"$CM\" ] && [ -n \"$CS\" ]; then ACTUAL=\"$CS\"; else ACTUAL=$( (sha256sum \"$PLAN_FILE\" 2>/dev/null || shasum -a 256 \"$PLAN_FILE\" 2>/dev/null) | awk '{print $1}'); [ -n \"$ACTUAL\" ] && [ -n \"$MT\" ] && printf \"%s\\n%s\\n\" \"$MT\" \"$ACTUAL\" > \"$CF\" 2>/dev/null; fi; [ \"$ACTUAL\" != \"$ATTEST\" ] && TAMPERED=1; fi; echo '[planning-with-files] PreCompact: context compaction is about to occur.'; echo 'Before compaction completes: ensure progress.md captures recent actions and task_plan.md status reflects current phase.'; echo 'task_plan.md, findings.md, progress.md remain on disk and will be re-read after compaction.'; [ -n \"$ATTEST\" ] && echo \"Plan-SHA256 at compaction: $ATTEST\"; exit 0"
|
||||
metadata:
|
||||
version: "3.4.1"
|
||||
version: "3.5.0"
|
||||
---
|
||||
|
||||
# Sistema de Planificación con Archivos
|
||||
|
||||
@@ -29,7 +29,7 @@ hooks:
|
||||
command: "RESOLVED=\"\"; SCOPE=\"\"; SLUG_RE='^[A-Za-z0-9_][A-Za-z0-9._-]*$'; if [ -n \"${PLAN_ID:-}\" ] && printf \"%s\" \"$PLAN_ID\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${PLAN_ID}\" ]; then RESOLVED=\".planning/${PLAN_ID}\"; SCOPE=\"scoped\"; elif [ -f .planning/.active_plan ]; then AP=$(tr -d '\\r\\n[:space:]' < .planning/.active_plan 2>/dev/null); if [ -n \"$AP\" ] && printf \"%s\" \"$AP\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${AP}\" ]; then RESOLVED=\".planning/${AP}\"; SCOPE=\"scoped\"; fi; fi; if [ -z \"$RESOLVED\" ] && [ -d .planning ]; then NEWEST=\"\"; NEWEST_MT=0; for d in .planning/*/; do d=\"${d%/}\"; n=$(basename \"$d\"); case \"$n\" in .*) continue;; esac; printf \"%s\" \"$n\" | grep -Eq \"$SLUG_RE\" || continue; [ -f \"$d/task_plan.md\" ] || continue; m=$(stat -c '%Y' \"$d\" 2>/dev/null || stat -f '%m' \"$d\" 2>/dev/null || date -r \"$d\" +%s 2>/dev/null || echo 0); if [ \"$m\" -gt \"$NEWEST_MT\" ] 2>/dev/null; then NEWEST_MT=\"$m\"; NEWEST=\"$d\"; fi; done; [ -n \"$NEWEST\" ] && { RESOLVED=\"$NEWEST\"; SCOPE=\"scoped\"; }; fi; if [ -z \"$RESOLVED\" ] && [ -f task_plan.md ]; then RESOLVED=\".\"; SCOPE=\"root\"; fi; [ -z \"$RESOLVED\" ] && exit 0; if [ \"$SCOPE\" = \"root\" ]; then PLAN_FILE=\"task_plan.md\"; PROGRESS_FILE=\"progress.md\"; ATTEST=\"\"; [ -f .plan-attestation ] && ATTEST=$(tr -d '\\r\\n[:space:]' < .plan-attestation 2>/dev/null); else PLAN_FILE=\"${RESOLVED}/task_plan.md\"; PROGRESS_FILE=\"${RESOLVED}/progress.md\"; ATTEST=\"\"; [ -f \"${RESOLVED}/.attestation\" ] && ATTEST=$(tr -d '\\r\\n[:space:]' < \"${RESOLVED}/.attestation\" 2>/dev/null); fi; [ -f \"$PLAN_FILE\" ] || exit 0; TAMPERED=0; ACTUAL=\"\"; if [ -n \"$ATTEST\" ]; then CD=\"${TMPDIR:-/tmp}/pwf-sha\"; mkdir -p \"$CD\" 2>/dev/null; KEY=$(printf \"%s\" \"$PLAN_FILE\" | { sha256sum 2>/dev/null || shasum -a 256 2>/dev/null; } | awk '{print $1}' | cut -c1-16); MT=$(stat -c '%Y' \"$PLAN_FILE\" 2>/dev/null || stat -f '%m' \"$PLAN_FILE\" 2>/dev/null || date -r \"$PLAN_FILE\" +%s 2>/dev/null || echo 0); CF=\"$CD/$KEY\"; CM=\"\"; CS=\"\"; if [ -f \"$CF\" ]; then CM=$(sed -n 1p \"$CF\" 2>/dev/null); CS=$(sed -n 2p \"$CF\" 2>/dev/null); fi; if [ -n \"$MT\" ] && [ \"$MT\" = \"$CM\" ] && [ -n \"$CS\" ]; then ACTUAL=\"$CS\"; else ACTUAL=$( (sha256sum \"$PLAN_FILE\" 2>/dev/null || shasum -a 256 \"$PLAN_FILE\" 2>/dev/null) | awk '{print $1}'); [ -n \"$ACTUAL\" ] && [ -n \"$MT\" ] && printf \"%s\\n%s\\n\" \"$MT\" \"$ACTUAL\" > \"$CF\" 2>/dev/null; fi; [ \"$ACTUAL\" != \"$ATTEST\" ] && TAMPERED=1; fi; echo '[planning-with-files] PreCompact: context compaction is about to occur.'; echo 'Before compaction completes: ensure progress.md captures recent actions and task_plan.md status reflects current phase.'; echo 'task_plan.md, findings.md, progress.md remain on disk and will be re-read after compaction.'; [ -n \"$ATTEST\" ] && echo \"Plan-SHA256 at compaction: $ATTEST\"; exit 0"
|
||||
metadata:
|
||||
|
||||
version: "3.4.1"
|
||||
version: "3.5.0"
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -29,7 +29,7 @@ hooks:
|
||||
command: "RESOLVED=\"\"; SCOPE=\"\"; SLUG_RE='^[A-Za-z0-9_][A-Za-z0-9._-]*$'; if [ -n \"${PLAN_ID:-}\" ] && printf \"%s\" \"$PLAN_ID\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${PLAN_ID}\" ]; then RESOLVED=\".planning/${PLAN_ID}\"; SCOPE=\"scoped\"; elif [ -f .planning/.active_plan ]; then AP=$(tr -d '\\r\\n[:space:]' < .planning/.active_plan 2>/dev/null); if [ -n \"$AP\" ] && printf \"%s\" \"$AP\" | grep -Eq \"$SLUG_RE\" && [ -d \".planning/${AP}\" ]; then RESOLVED=\".planning/${AP}\"; SCOPE=\"scoped\"; fi; fi; if [ -z \"$RESOLVED\" ] && [ -d .planning ]; then NEWEST=\"\"; NEWEST_MT=0; for d in .planning/*/; do d=\"${d%/}\"; n=$(basename \"$d\"); case \"$n\" in .*) continue;; esac; printf \"%s\" \"$n\" | grep -Eq \"$SLUG_RE\" || continue; [ -f \"$d/task_plan.md\" ] || continue; m=$(stat -c '%Y' \"$d\" 2>/dev/null || stat -f '%m' \"$d\" 2>/dev/null || date -r \"$d\" +%s 2>/dev/null || echo 0); if [ \"$m\" -gt \"$NEWEST_MT\" ] 2>/dev/null; then NEWEST_MT=\"$m\"; NEWEST=\"$d\"; fi; done; [ -n \"$NEWEST\" ] && { RESOLVED=\"$NEWEST\"; SCOPE=\"scoped\"; }; fi; if [ -z \"$RESOLVED\" ] && [ -f task_plan.md ]; then RESOLVED=\".\"; SCOPE=\"root\"; fi; [ -z \"$RESOLVED\" ] && exit 0; if [ \"$SCOPE\" = \"root\" ]; then PLAN_FILE=\"task_plan.md\"; PROGRESS_FILE=\"progress.md\"; ATTEST=\"\"; [ -f .plan-attestation ] && ATTEST=$(tr -d '\\r\\n[:space:]' < .plan-attestation 2>/dev/null); else PLAN_FILE=\"${RESOLVED}/task_plan.md\"; PROGRESS_FILE=\"${RESOLVED}/progress.md\"; ATTEST=\"\"; [ -f \"${RESOLVED}/.attestation\" ] && ATTEST=$(tr -d '\\r\\n[:space:]' < \"${RESOLVED}/.attestation\" 2>/dev/null); fi; [ -f \"$PLAN_FILE\" ] || exit 0; TAMPERED=0; ACTUAL=\"\"; if [ -n \"$ATTEST\" ]; then CD=\"${TMPDIR:-/tmp}/pwf-sha\"; mkdir -p \"$CD\" 2>/dev/null; KEY=$(printf \"%s\" \"$PLAN_FILE\" | { sha256sum 2>/dev/null || shasum -a 256 2>/dev/null; } | awk '{print $1}' | cut -c1-16); MT=$(stat -c '%Y' \"$PLAN_FILE\" 2>/dev/null || stat -f '%m' \"$PLAN_FILE\" 2>/dev/null || date -r \"$PLAN_FILE\" +%s 2>/dev/null || echo 0); CF=\"$CD/$KEY\"; CM=\"\"; CS=\"\"; if [ -f \"$CF\" ]; then CM=$(sed -n 1p \"$CF\" 2>/dev/null); CS=$(sed -n 2p \"$CF\" 2>/dev/null); fi; if [ -n \"$MT\" ] && [ \"$MT\" = \"$CM\" ] && [ -n \"$CS\" ]; then ACTUAL=\"$CS\"; else ACTUAL=$( (sha256sum \"$PLAN_FILE\" 2>/dev/null || shasum -a 256 \"$PLAN_FILE\" 2>/dev/null) | awk '{print $1}'); [ -n \"$ACTUAL\" ] && [ -n \"$MT\" ] && printf \"%s\\n%s\\n\" \"$MT\" \"$ACTUAL\" > \"$CF\" 2>/dev/null; fi; [ \"$ACTUAL\" != \"$ATTEST\" ] && TAMPERED=1; fi; echo '[planning-with-files] PreCompact: context compaction is about to occur.'; echo 'Before compaction completes: ensure progress.md captures recent actions and task_plan.md status reflects current phase.'; echo 'task_plan.md, findings.md, progress.md remain on disk and will be re-read after compaction.'; [ -n \"$ATTEST\" ] && echo \"Plan-SHA256 at compaction: $ATTEST\"; exit 0"
|
||||
metadata:
|
||||
|
||||
version: "3.4.1"
|
||||
version: "3.5.0"
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -28,7 +28,7 @@ hooks:
|
||||
- type: command
|
||||
command: "SH=\"${CLAUDE_SKILL_DIR}/scripts/inject-plan.sh\"; [ -f \"$SH\" ] || SH=$(ls \"$HOME/.claude/skills/planning-with-files/scripts/inject-plan.sh\" \"$HOME/.claude/plugins/marketplaces/planning-with-files/scripts/inject-plan.sh\" 2>/dev/null | head -1); [ -n \"$SH\" ] && [ -f \"$SH\" ] && sh \"$SH\" --context=precompact; exit 0"
|
||||
metadata:
|
||||
version: "3.4.1"
|
||||
version: "3.5.0"
|
||||
---
|
||||
|
||||
# Planning with Files
|
||||
|
||||
@@ -72,7 +72,9 @@ is_within_root() {
|
||||
root_real="$(canonicalize "${PWD}")" || root_real=""
|
||||
cand_real="$(canonicalize "${candidate}")" || cand_real=""
|
||||
if [ -z "${root_real}" ] || [ -z "${cand_real}" ]; then
|
||||
return 0
|
||||
# Slug validation blocks textual traversal, but only successful
|
||||
# canonicalization can rule out a symlink/junction escape.
|
||||
return 1
|
||||
fi
|
||||
case "${cand_real}" in
|
||||
"${root_real}"|"${root_real}"/*) return 0 ;;
|
||||
@@ -119,6 +121,12 @@ resolve_from_env() {
|
||||
resolve_from_active_file() {
|
||||
[ -f "${ACTIVE_FILE}" ] || return 1
|
||||
plan_id="$(tr -d '\r\n[:space:]' < "${ACTIVE_FILE}")"
|
||||
# UTF-8 BOM is not part of the plan id. POSIX printf octal escapes keep
|
||||
# this portable across GNU/BSD sed variants and Git-for-Windows sh.
|
||||
utf8_bom="$(printf '\357\273\277')"
|
||||
case "${plan_id}" in
|
||||
"${utf8_bom}"*) plan_id="${plan_id#"${utf8_bom}"}" ;;
|
||||
esac
|
||||
slug_is_valid "${plan_id}" || return 1
|
||||
candidate="${PLAN_ROOT}/${plan_id}"
|
||||
if [ -d "${candidate}" ] && is_within_root "${candidate}"; then
|
||||
|
||||
@@ -14,6 +14,30 @@ import os
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, Iterable, List, Optional, Tuple
|
||||
|
||||
|
||||
def configure_utf8_stdio() -> None:
|
||||
"""Make catchup output deterministic on Windows legacy code pages.
|
||||
|
||||
Codex sessions and planning files are UTF-8 and can contain arbitrary
|
||||
Unicode. Windows PowerShell may nevertheless launch Python with a cp1252
|
||||
(or another OEM/ANSI) stdout codec. A report containing Chinese text then
|
||||
used to fail at the first ``print`` with ``UnicodeEncodeError``. Configure
|
||||
both streams before any report is emitted; ``errors='replace'`` also keeps
|
||||
this advisory hook fail-safe if a malformed surrogate reaches the output.
|
||||
"""
|
||||
for stream in (sys.stdout, sys.stderr):
|
||||
reconfigure = getattr(stream, 'reconfigure', None)
|
||||
if callable(reconfigure):
|
||||
try:
|
||||
reconfigure(encoding='utf-8', errors='replace')
|
||||
except (OSError, ValueError):
|
||||
# Replaced/captured streams may not permit reconfiguration.
|
||||
# The hook remains advisory, so retain the existing stream.
|
||||
pass
|
||||
|
||||
|
||||
configure_utf8_stdio()
|
||||
|
||||
try:
|
||||
import orjson
|
||||
except ImportError:
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
# planning-with-files: set or display the active plan pointer (PowerShell).
|
||||
#
|
||||
# Usage:
|
||||
# .\set-active-plan.ps1 <plan_id> — pin .planning\.active_plan to plan_id
|
||||
# .\set-active-plan.ps1 — print the current active plan (if any)
|
||||
# .\set-active-plan.ps1 <plan_id> - pin .planning\.active_plan to plan_id
|
||||
# .\set-active-plan.ps1 - print the current active plan (if any)
|
||||
|
||||
param(
|
||||
[string]$PlanId = ""
|
||||
@@ -19,7 +19,7 @@ if ($PlanId -eq "") {
|
||||
Write-Output "Active plan: $current"
|
||||
Write-Output "Path: $planDir"
|
||||
} elseif ($current -ne "") {
|
||||
Write-Output "Active plan pointer: $current (directory not found — stale pointer)"
|
||||
Write-Output "Active plan pointer: $current (directory not found - stale pointer)"
|
||||
} else {
|
||||
Write-Output "No active plan set."
|
||||
}
|
||||
@@ -41,7 +41,8 @@ if (-not (Test-Path $PlanRoot)) {
|
||||
New-Item -ItemType Directory -Path $PlanRoot -Force | Out-Null
|
||||
}
|
||||
|
||||
Set-Content -Path $ActiveFile -Value $PlanId -Encoding UTF8 -NoNewline
|
||||
$utf8NoBom = New-Object System.Text.UTF8Encoding($false)
|
||||
[System.IO.File]::WriteAllText($ActiveFile, $PlanId, $utf8NoBom)
|
||||
|
||||
Write-Output "Active plan set to: $PlanId"
|
||||
Write-Output "Path: $PlanDir"
|
||||
|
||||
+126
-12
@@ -1,11 +1,14 @@
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import textwrap
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from unittest import mock
|
||||
|
||||
|
||||
REPO_ROOT = Path(__file__).resolve().parents[1]
|
||||
@@ -27,13 +30,32 @@ class CodexHooksTests(unittest.TestCase):
|
||||
)
|
||||
|
||||
def run_shell_hook(self, script_name: str, cwd: Path, env: dict | None = None) -> subprocess.CompletedProcess[str]:
|
||||
shell_env = (env or os.environ).copy()
|
||||
shell = shutil.which("sh", path=shell_env.get("PATH"))
|
||||
if os.name == "nt":
|
||||
sys.path.insert(0, str(HOOKS_DIR))
|
||||
try:
|
||||
import codex_hook_adapter as adapter
|
||||
|
||||
shell, extra_path_dirs = adapter._windows_git_bash()
|
||||
finally:
|
||||
sys.path.pop(0)
|
||||
if shell is None:
|
||||
raise unittest.SkipTest("Git for Windows sh.exe is unavailable")
|
||||
if extra_path_dirs:
|
||||
shell_env["PATH"] = os.pathsep.join(
|
||||
[*extra_path_dirs, shell_env.get("PATH", "")]
|
||||
)
|
||||
shell_env.setdefault("PYTHON_BIN", sys.executable)
|
||||
elif shell is None:
|
||||
raise unittest.SkipTest("POSIX sh is unavailable")
|
||||
return subprocess.run(
|
||||
["sh", str(HOOKS_DIR / script_name)],
|
||||
[shell, str(HOOKS_DIR / script_name)],
|
||||
text=True,
|
||||
encoding="utf-8",
|
||||
capture_output=True,
|
||||
cwd=str(cwd),
|
||||
env=env,
|
||||
env=shell_env,
|
||||
check=False,
|
||||
)
|
||||
|
||||
@@ -64,6 +86,10 @@ class CodexHooksTests(unittest.TestCase):
|
||||
},
|
||||
set(payload["hooks"]),
|
||||
)
|
||||
self.assertEqual(
|
||||
"startup|resume|clear|compact",
|
||||
payload["hooks"]["SessionStart"][0]["matcher"],
|
||||
)
|
||||
|
||||
def test_permission_request_adapter_emits_plan_reminder(self) -> None:
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
@@ -96,6 +122,24 @@ class CodexHooksTests(unittest.TestCase):
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual("", result.stdout.strip())
|
||||
|
||||
def test_permission_request_resolves_scoped_plan(self) -> None:
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
root = Path(tmpdir)
|
||||
plan_dir = root / ".planning" / "task-a"
|
||||
plan_dir.mkdir(parents=True)
|
||||
plan_dir.joinpath("task_plan.md").write_text("# Scoped Plan\n", encoding="utf-8")
|
||||
root.joinpath(".planning", ".active_plan").write_text("task-a\n", encoding="utf-8")
|
||||
|
||||
result = self.run_python_hook(
|
||||
"permission_request.py",
|
||||
{"cwd": str(root), "tool_name": "Bash"},
|
||||
root,
|
||||
)
|
||||
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
payload = json.loads(result.stdout)
|
||||
self.assertIn("Active plan", payload["systemMessage"])
|
||||
|
||||
def test_session_start_reuses_plan_context(self) -> None:
|
||||
with tempfile.TemporaryDirectory() as tmpdir, tempfile.TemporaryDirectory() as home:
|
||||
root = Path(tmpdir)
|
||||
@@ -121,7 +165,7 @@ class CodexHooksTests(unittest.TestCase):
|
||||
self.assertIn("Ship Codex hooks", result.stdout)
|
||||
self.assertIn("Finished adapter draft", result.stdout)
|
||||
|
||||
def test_pre_tool_use_adapter_emits_system_message(self) -> None:
|
||||
def test_pre_tool_use_adapter_emits_additional_context(self) -> None:
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
root = Path(tmpdir)
|
||||
root.joinpath("task_plan.md").write_text(
|
||||
@@ -143,8 +187,25 @@ class CodexHooksTests(unittest.TestCase):
|
||||
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
payload = json.loads(result.stdout)
|
||||
self.assertIn("systemMessage", payload)
|
||||
self.assertIn("# Task Plan", payload["systemMessage"])
|
||||
hook_output = payload["hookSpecificOutput"]
|
||||
self.assertEqual("PreToolUse", hook_output["hookEventName"])
|
||||
self.assertIn("# Task Plan", hook_output["additionalContext"])
|
||||
|
||||
def test_pre_tool_use_adapter_preserves_unicode_as_ascii_safe_json(self) -> None:
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
root = Path(tmpdir)
|
||||
root.joinpath("task_plan.md").write_text("# \u4efb\u52a1\u8ba1\u5212\n", encoding="utf-8")
|
||||
|
||||
result = self.run_python_hook(
|
||||
"pre_tool_use.py",
|
||||
{"cwd": str(root), "tool_input": {"command": "pwd"}},
|
||||
root,
|
||||
)
|
||||
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertTrue(result.stdout.isascii())
|
||||
payload = json.loads(result.stdout)
|
||||
self.assertIn("\u4efb\u52a1\u8ba1\u5212", payload["hookSpecificOutput"]["additionalContext"])
|
||||
|
||||
def test_post_tool_use_adapter_emits_progress_reminder(self) -> None:
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
@@ -240,9 +301,45 @@ class CodexHooksTests(unittest.TestCase):
|
||||
for bad in ("$HOME", "2>/dev/null", "|| true", "python3 "):
|
||||
self.assertNotIn(bad, cw, f"{event} commandWindows still contains POSIX-ism {bad!r}")
|
||||
|
||||
def test_adapter_uses_explicit_utf8_for_shell_output(self) -> None:
|
||||
sys.path.insert(0, str(HOOKS_DIR))
|
||||
try:
|
||||
import codex_hook_adapter as adapter
|
||||
|
||||
completed = subprocess.CompletedProcess(["sh"], 0, "ok\n", "")
|
||||
with mock.patch.object(adapter, "_windows_git_bash", return_value=("sh", [])), mock.patch.object(
|
||||
adapter.subprocess, "run", return_value=completed
|
||||
) as run:
|
||||
stdout, stderr = adapter.run_shell_script("user-prompt-submit.sh", Path.cwd())
|
||||
finally:
|
||||
sys.path.pop(0)
|
||||
|
||||
self.assertEqual("ok", stdout)
|
||||
self.assertEqual("", stderr)
|
||||
self.assertEqual("utf-8", run.call_args.kwargs["encoding"])
|
||||
self.assertEqual("replace", run.call_args.kwargs["errors"])
|
||||
|
||||
def test_emit_json_is_ascii_safe_and_round_trips_unicode(self) -> None:
|
||||
sys.path.insert(0, str(HOOKS_DIR))
|
||||
try:
|
||||
import codex_hook_adapter as adapter
|
||||
|
||||
buffer = io.BytesIO()
|
||||
stream = io.TextIOWrapper(buffer, encoding="ascii")
|
||||
with mock.patch.object(adapter.sys, "stdout", stream):
|
||||
adapter.emit_json({"message": "\u4e2d\u6587"})
|
||||
stream.flush()
|
||||
raw = buffer.getvalue().decode("ascii")
|
||||
stream.detach()
|
||||
finally:
|
||||
sys.path.pop(0)
|
||||
|
||||
self.assertTrue(raw.isascii())
|
||||
self.assertEqual("\u4e2d\u6587", json.loads(raw)["message"])
|
||||
|
||||
@unittest.skipUnless(os.name == "nt", "commandWindows path is Windows-only")
|
||||
def test_run_sh_front_door_injects_plan_on_windows(self) -> None:
|
||||
"""End-to-end Windows path: run_sh.py -> adapter git-bash resolver -> .sh."""
|
||||
def test_run_sh_front_door_serializes_shell_events_on_windows(self) -> None:
|
||||
"""End-to-end Windows path emits event-appropriate Codex JSON."""
|
||||
sys.path.insert(0, str(HOOKS_DIR))
|
||||
try:
|
||||
import codex_hook_adapter as adapter
|
||||
@@ -255,13 +352,30 @@ class CodexHooksTests(unittest.TestCase):
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
root = Path(tmpdir)
|
||||
root.joinpath("task_plan.md").write_text(
|
||||
"# Task Plan\n\n## Goal\nWindows hook parity\n", encoding="utf-8"
|
||||
"# \u4efb\u52a1\u8ba1\u5212\n\n## Goal\nWindows hook parity\n", encoding="utf-8"
|
||||
)
|
||||
result = self.run_windows_front_door("user-prompt-submit.sh", {"cwd": str(root)}, root)
|
||||
root.joinpath("progress.md").write_text("# Progress\n", encoding="utf-8")
|
||||
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertIn("ACTIVE PLAN", result.stdout)
|
||||
self.assertIn("Windows hook parity", result.stdout)
|
||||
user_prompt = self.run_windows_front_door("user-prompt-submit.sh", {"cwd": str(root)}, root)
|
||||
session_start = self.run_windows_front_door("session-start.sh", {"cwd": str(root)}, root)
|
||||
pre_compact = self.run_windows_front_door("pre-compact.sh", {"cwd": str(root)}, root)
|
||||
|
||||
for result in (user_prompt, session_start, pre_compact):
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertTrue(result.stdout.isascii())
|
||||
|
||||
user_payload = json.loads(user_prompt.stdout)
|
||||
self.assertEqual("UserPromptSubmit", user_payload["hookSpecificOutput"]["hookEventName"])
|
||||
self.assertIn("Windows hook parity", user_payload["hookSpecificOutput"]["additionalContext"])
|
||||
self.assertIn("\u4efb\u52a1\u8ba1\u5212", user_payload["hookSpecificOutput"]["additionalContext"])
|
||||
|
||||
session_payload = json.loads(session_start.stdout)
|
||||
self.assertEqual("SessionStart", session_payload["hookSpecificOutput"]["hookEventName"])
|
||||
self.assertIn("Windows hook parity", session_payload["hookSpecificOutput"]["additionalContext"])
|
||||
|
||||
compact_payload = json.loads(pre_compact.stdout)
|
||||
self.assertTrue(compact_payload["continue"])
|
||||
self.assertIn("PreCompact", compact_payload["systemMessage"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@@ -121,11 +121,7 @@ class CodexSessionIsolationTests(unittest.TestCase):
|
||||
payload = {"cwd": str(root), "session_id": "sess-B"}
|
||||
result = self.run_python_hook("pre_tool_use.py", payload, root)
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
# No systemMessage payload should be emitted
|
||||
stdout = result.stdout.strip()
|
||||
if stdout:
|
||||
emitted = json.loads(stdout)
|
||||
self.assertNotIn("systemMessage", emitted)
|
||||
self.assertEqual("", result.stdout.strip())
|
||||
|
||||
def test_stop_does_not_block_unattached_session(self) -> None:
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
|
||||
@@ -8,7 +8,9 @@ by exercising the full hook→resolver→plan-file chain.
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
@@ -18,13 +20,36 @@ REPO_ROOT = Path(__file__).resolve().parents[1]
|
||||
HOOKS_DIR = REPO_ROOT / ".codex" / "hooks"
|
||||
|
||||
|
||||
def run_hook(script: str, cwd: Path, env_extra: dict | None = None) -> subprocess.CompletedProcess[str]:
|
||||
def shell_and_env() -> tuple[str, dict[str, str]]:
|
||||
env = os.environ.copy()
|
||||
if os.name != "nt":
|
||||
shell = shutil.which("sh")
|
||||
if shell is None:
|
||||
raise unittest.SkipTest("POSIX sh is unavailable")
|
||||
return shell, env
|
||||
|
||||
sys.path.insert(0, str(HOOKS_DIR))
|
||||
try:
|
||||
import codex_hook_adapter as adapter
|
||||
|
||||
shell, extra_path_dirs = adapter._windows_git_bash()
|
||||
finally:
|
||||
sys.path.pop(0)
|
||||
if shell is None:
|
||||
raise unittest.SkipTest("Git for Windows sh.exe is unavailable")
|
||||
if extra_path_dirs:
|
||||
env["PATH"] = os.pathsep.join([*extra_path_dirs, env.get("PATH", "")])
|
||||
env.setdefault("PYTHON_BIN", sys.executable)
|
||||
return shell, env
|
||||
|
||||
|
||||
def run_hook(script: str, cwd: Path, env_extra: dict | None = None) -> subprocess.CompletedProcess[str]:
|
||||
shell, env = shell_and_env()
|
||||
env.pop("PLAN_ID", None)
|
||||
if env_extra:
|
||||
env.update(env_extra)
|
||||
return subprocess.run(
|
||||
["sh", str(HOOKS_DIR / script)],
|
||||
[shell, str(HOOKS_DIR / script)],
|
||||
cwd=str(cwd),
|
||||
text=True,
|
||||
encoding="utf-8",
|
||||
@@ -46,6 +71,12 @@ def write_plan_in_dir(plan_dir: Path, goal: str = "Ship the feature") -> None:
|
||||
|
||||
class HookResolverIntegrationTests(unittest.TestCase):
|
||||
|
||||
def test_global_resolver_is_a_thin_canonical_forwarder(self) -> None:
|
||||
resolver = (HOOKS_DIR / "resolve-plan-dir.sh").read_text(encoding="utf-8")
|
||||
self.assertIn("../skills/planning-with-files/scripts/resolve-plan-dir.sh", resolver)
|
||||
self.assertIn('exec sh "${CANONICAL_RESOLVER}" "$@"', resolver)
|
||||
self.assertNotIn("resolve_latest_dir()", resolver)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# user-prompt-submit.sh
|
||||
# ------------------------------------------------------------------
|
||||
@@ -94,6 +125,84 @@ class HookResolverIntegrationTests(unittest.TestCase):
|
||||
self.assertIn("Task A goal", result.stdout)
|
||||
self.assertNotIn("Task B goal", result.stdout)
|
||||
|
||||
def test_user_prompt_submit_accepts_utf8_bom_active_pointer(self) -> None:
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
root = Path(tmp)
|
||||
safe = root / ".planning" / "safe"
|
||||
write_plan_in_dir(safe, goal="BOM-safe goal")
|
||||
decoy = root / ".planning" / "newer-decoy"
|
||||
write_plan_in_dir(decoy, goal="Newest fallback goal")
|
||||
# If BOM stripping regresses, newest-dir fallback must select the
|
||||
# decoy and make this test fail instead of masking the bug.
|
||||
os.utime(safe, (100, 100))
|
||||
os.utime(decoy, (200, 200))
|
||||
(root / ".planning" / ".active_plan").write_bytes(b"\xef\xbb\xbfsafe\n")
|
||||
|
||||
result = run_hook("user-prompt-submit.sh", root)
|
||||
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertIn("BOM-safe goal", result.stdout)
|
||||
self.assertNotIn("Newest fallback goal", result.stdout)
|
||||
|
||||
def test_user_prompt_submit_rejects_traversal_plan_id(self) -> None:
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
root = Path(tmp)
|
||||
write_plan_in_dir(root / ".planning" / "safe", goal="Workspace plan")
|
||||
write_plan_in_dir(root / "outside", goal="Escaped plan")
|
||||
(root / ".planning" / ".active_plan").write_text("safe\n", encoding="utf-8")
|
||||
|
||||
result = run_hook(
|
||||
"user-prompt-submit.sh",
|
||||
root,
|
||||
env_extra={"PLAN_ID": "../outside"},
|
||||
)
|
||||
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertIn("Workspace plan", result.stdout)
|
||||
self.assertNotIn("Escaped plan", result.stdout)
|
||||
|
||||
def test_user_prompt_submit_rejects_external_symlink_plan(self) -> None:
|
||||
with tempfile.TemporaryDirectory() as tmp, tempfile.TemporaryDirectory() as outside_tmp:
|
||||
root = Path(tmp)
|
||||
safe = root / ".planning" / "safe"
|
||||
outside = Path(outside_tmp) / "outside"
|
||||
write_plan_in_dir(safe, goal="Workspace plan")
|
||||
write_plan_in_dir(outside, goal="Escaped plan")
|
||||
(root / ".planning" / ".active_plan").write_text("safe\n", encoding="utf-8")
|
||||
escape = root / ".planning" / "escape"
|
||||
try:
|
||||
try:
|
||||
escape.symlink_to(outside, target_is_directory=True)
|
||||
except OSError as symlink_error:
|
||||
if os.name != "nt":
|
||||
self.skipTest(f"directory symlinks are unavailable: {symlink_error}")
|
||||
junction = subprocess.run(
|
||||
["cmd", "/d", "/c", "mklink", "/J", str(escape), str(outside)],
|
||||
text=True,
|
||||
encoding="utf-8",
|
||||
errors="replace",
|
||||
capture_output=True,
|
||||
check=False,
|
||||
)
|
||||
if junction.returncode != 0:
|
||||
self.skipTest("directory symlinks and junctions are unavailable")
|
||||
|
||||
result = run_hook(
|
||||
"user-prompt-submit.sh",
|
||||
root,
|
||||
env_extra={"PLAN_ID": "escape"},
|
||||
)
|
||||
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertIn("Workspace plan", result.stdout)
|
||||
self.assertNotIn("Escaped plan", result.stdout)
|
||||
finally:
|
||||
if escape.is_symlink():
|
||||
escape.unlink()
|
||||
elif os.name == "nt" and escape.exists():
|
||||
# os.rmdir removes the junction itself, never its target.
|
||||
os.rmdir(escape)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# pre-tool-use.sh
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
@@ -3,6 +3,8 @@ import io
|
||||
import json
|
||||
import os
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
from contextlib import redirect_stdout
|
||||
@@ -238,6 +240,50 @@ class SessionCatchupCodexTests(unittest.TestCase):
|
||||
self.assertIn("Last planning update: task_plan.md", output)
|
||||
self.assertIn("CODEX: Codex summary after planning update", output)
|
||||
|
||||
def test_codex_cli_prints_unicode_when_parent_requests_cp1252(self):
|
||||
for filename in self.module.PLANNING_FILES:
|
||||
(self.project_dir / filename).write_text("# test\n", encoding="utf-8")
|
||||
self.write_codex_session(
|
||||
"rollout-2026-04-07T00-00-00-unicode-thread.jsonl",
|
||||
records=[
|
||||
{
|
||||
"timestamp": "2026-04-07T00:00:02.000Z",
|
||||
"type": "event_msg",
|
||||
"payload": {
|
||||
"type": "patch_apply_end",
|
||||
"success": True,
|
||||
"changes": {"task_plan.md": {"operation": "modified"}},
|
||||
},
|
||||
},
|
||||
{
|
||||
"timestamp": "2026-04-07T00:00:03.000Z",
|
||||
"type": "response_item",
|
||||
"payload": {
|
||||
"type": "message",
|
||||
"role": "assistant",
|
||||
"content": [
|
||||
{"type": "output_text", "text": "继续完成中文计划"},
|
||||
],
|
||||
},
|
||||
},
|
||||
],
|
||||
)
|
||||
env = os.environ.copy()
|
||||
env["CODEX_SESSIONS_DIR"] = str(self.sessions_dir)
|
||||
env["PYTHONIOENCODING"] = "cp1252"
|
||||
env.pop("CODEX_THREAD_ID", None)
|
||||
|
||||
result = subprocess.run(
|
||||
[sys.executable, str(self.codex_script), self.project_path],
|
||||
capture_output=True,
|
||||
encoding="utf-8",
|
||||
env=env,
|
||||
check=False,
|
||||
)
|
||||
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertIn("继续完成中文计划", result.stdout)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
||||
@@ -6,6 +6,8 @@ init-session.sh for parallel multi-task workflows (#148).
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
@@ -14,6 +16,10 @@ from pathlib import Path
|
||||
|
||||
REPO_ROOT = Path(__file__).resolve().parents[1]
|
||||
SET_ACTIVE_SH = REPO_ROOT / "scripts" / "set-active-plan.sh"
|
||||
SET_ACTIVE_PS1 = REPO_ROOT / "scripts" / "set-active-plan.ps1"
|
||||
RESOLVE_SH = REPO_ROOT / "scripts" / "resolve-plan-dir.sh"
|
||||
POWERSHELL = shutil.which("powershell.exe") or shutil.which("powershell")
|
||||
SH = shutil.which("sh")
|
||||
|
||||
|
||||
def run_set_active(cwd: Path, *args: str) -> subprocess.CompletedProcess[str]:
|
||||
@@ -32,6 +38,68 @@ class SetActivePlanTests(unittest.TestCase):
|
||||
def test_script_exists(self) -> None:
|
||||
self.assertTrue(SET_ACTIVE_SH.exists(), "scripts/set-active-plan.sh missing")
|
||||
|
||||
def test_powershell_script_is_ascii_safe_for_windows_powershell_5(self) -> None:
|
||||
"""UTF-8 without a BOM must not become invalid Windows PowerShell syntax."""
|
||||
self.assertTrue(SET_ACTIVE_PS1.exists(), "scripts/set-active-plan.ps1 missing")
|
||||
try:
|
||||
SET_ACTIVE_PS1.read_bytes().decode("ascii")
|
||||
except UnicodeDecodeError as error:
|
||||
self.fail(
|
||||
"set-active-plan.ps1 must stay ASCII-safe because Windows PowerShell 5.1 "
|
||||
f"can decode BOM-less UTF-8 as the active ANSI code page: {error}"
|
||||
)
|
||||
|
||||
@unittest.skipUnless(
|
||||
POWERSHELL and SH,
|
||||
"requires Windows PowerShell and sh for the cross-shell regression test",
|
||||
)
|
||||
def test_powershell_pointer_is_utf8_without_bom_and_resolves(self) -> None:
|
||||
"""The PS 5.1 writer must not add a BOM that the shell resolver rejects."""
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
root = Path(tmp)
|
||||
selected = root / ".planning" / "selected"
|
||||
newest = root / ".planning" / "newest"
|
||||
selected.mkdir(parents=True)
|
||||
newest.mkdir(parents=True)
|
||||
(selected / "task_plan.md").write_text("# Selected\n", encoding="utf-8")
|
||||
(newest / "task_plan.md").write_text("# Newest\n", encoding="utf-8")
|
||||
selected_mtime = selected.stat().st_mtime
|
||||
os.utime(newest, (selected_mtime + 10, selected_mtime + 10))
|
||||
|
||||
written = subprocess.run(
|
||||
[
|
||||
POWERSHELL,
|
||||
"-NoProfile",
|
||||
"-ExecutionPolicy",
|
||||
"Bypass",
|
||||
"-File",
|
||||
str(SET_ACTIVE_PS1),
|
||||
"selected",
|
||||
],
|
||||
cwd=str(root),
|
||||
text=True,
|
||||
encoding="utf-8",
|
||||
errors="replace",
|
||||
capture_output=True,
|
||||
check=False,
|
||||
)
|
||||
self.assertEqual(0, written.returncode, written.stderr)
|
||||
self.assertEqual(
|
||||
b"selected",
|
||||
(root / ".planning" / ".active_plan").read_bytes(),
|
||||
)
|
||||
|
||||
resolved = subprocess.run(
|
||||
[SH, str(RESOLVE_SH)],
|
||||
cwd=str(root),
|
||||
text=True,
|
||||
encoding="utf-8",
|
||||
capture_output=True,
|
||||
check=False,
|
||||
)
|
||||
self.assertEqual(0, resolved.returncode, resolved.stderr)
|
||||
self.assertTrue(resolved.stdout.strip().endswith("selected"))
|
||||
|
||||
def test_no_args_no_active_plan_prints_none(self) -> None:
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
result = run_set_active(Path(tmp))
|
||||
|
||||
Reference in New Issue
Block a user