waypoint-codex 1.0.16 → 1.0.18

package/dist/src/upgrade.js

@@ -76,18 +76,90 @@ export function compareVersions(left, right) {
     }
     return 0;
 }
-function latestWaypointVersion(options) {
-    const npmBinary = options.npmBinary ?? process.env.WAYPOINT_NPM_COMMAND ?? npmBinaryForPlatform();
-    const latest = spawnSync(npmBinary, ["view", "waypoint-codex", "version"], {
+function spawnNpmPipe(npmBinary, args) {
+    const result = spawnSync(npmBinary, args, {
         stdio: "pipe",
         encoding: "utf8",
     });
-    if ((latest.status ?? 1) !== 0) {
+    return {
+        status: result.status ?? 1,
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? "",
+    };
+}
+function writePipedOutput(result, stdio) {
+    if (stdio !== "inherit") {
+        return;
+    }
+    if (result.stdout.length > 0) {
+        process.stdout.write(result.stdout);
+    }
+    if (result.stderr.length > 0) {
+        process.stderr.write(result.stderr);
+    }
+}
+function latestWaypointVersion(options) {
+    const npmBinary = options.npmBinary ?? process.env.WAYPOINT_NPM_COMMAND ?? npmBinaryForPlatform();
+    const latest = spawnNpmPipe(npmBinary, ["view", "waypoint-codex", "version"]);
+    if (latest.status !== 0) {
         return null;
     }
-    const version = latest.stdout?.trim();
+    const version = latest.stdout.trim();
     return version ? version : null;
 }
+function latestWaypointTarballUrl(options) {
+    const tarball = spawnNpmPipe(options.npmBinary, ["view", `waypoint-codex@${options.version}`, "dist.tarball"]);
+    if (tarball.status !== 0) {
+        return null;
+    }
+    const tarballUrl = tarball.stdout.trim();
+    return tarballUrl.length > 0 ? tarballUrl : null;
+}
+function appendCacheBust(url) {
+    try {
+        const parsed = new URL(url);
+        parsed.searchParams.set("waypointCacheBust", `${Date.now()}`);
+        return parsed.toString();
+    }
+    catch {
+        const separator = url.includes("?") ? "&" : "?";
+        return `${url}${separator}waypointCacheBust=${Date.now()}`;
+    }
+}
+function isTransientTarball404(result) {
+    const combined = `${result.stdout}\n${result.stderr}`;
+    return /E404/.test(combined) && /waypoint-codex-.*\.tgz/i.test(combined);
+}
+function installLatestWaypointCli(options) {
+    const primary = spawnNpmPipe(options.npmBinary, ["install", "-g", "waypoint-codex@latest"]);
+    if (primary.status === 0) {
+        writePipedOutput(primary, options.stdio);
+        return 0;
+    }
+    if (!isTransientTarball404(primary)) {
+        writePipedOutput(primary, options.stdio);
+        return primary.status;
+    }
+    const latestVersion = options.knownLatestVersion ?? latestWaypointVersion({ npmBinary: options.npmBinary });
+    if (!latestVersion) {
+        writePipedOutput(primary, options.stdio);
+        return primary.status;
+    }
+    const tarballUrl = latestWaypointTarballUrl({
+        npmBinary: options.npmBinary,
+        version: latestVersion,
+    });
+    if (!tarballUrl) {
+        writePipedOutput(primary, options.stdio);
+        return primary.status;
+    }
+    if (options.stdio === "inherit") {
+        console.log(`Waypoint npm install hit a transient tarball 404 for ${latestVersion}. Retrying with cache-busted URL...`);
+    }
+    const fallback = spawnNpmPipe(options.npmBinary, ["install", "-g", appendCacheBust(tarballUrl)]);
+    writePipedOutput(fallback, options.stdio);
+    return fallback.status;
+}
 function hasWaypointConfig(projectRoot) {
     return existsSync(path.join(projectRoot, ".waypoint/config.toml"));
 }
@@ -95,11 +167,12 @@ export function upgradeWaypoint(options) {
     const nodeBinary = options.nodeBinary ?? process.execPath;
     const npmBinary = options.npmBinary ?? process.env.WAYPOINT_NPM_COMMAND ?? npmBinaryForPlatform();
     const stdio = options.stdio ?? "inherit";
-    const update = spawnSync(npmBinary, ["install", "-g", "waypoint-codex@latest"], {
+    const updateStatus = installLatestWaypointCli({
+        npmBinary,
         stdio,
     });
-    if ((update.status ?? 1) !== 0) {
-        return update.status ?? 1;
+    if (updateStatus !== 0) {
+        return updateStatus;
     }
     if (options.skipRepoRefresh) {
         console.log("Waypoint CLI updated. Skipped repo refresh.");
@@ -129,11 +202,13 @@ export function maybeUpgradeWaypointBeforeInit(options) {
         return null;
     }
     console.log(`Waypoint CLI ${options.currentVersion} is older than latest ${latestVersion}. Updating before init...`);
-    const update = spawnSync(npmBinary, ["install", "-g", "waypoint-codex@latest"], {
+    const updateStatus = installLatestWaypointCli({
+        npmBinary,
         stdio,
+        knownLatestVersion: latestVersion,
     });
-    if ((update.status ?? 1) !== 0) {
-        return update.status ?? 1;
+    if (updateStatus !== 0) {
+        return updateStatus;
     }
     const reexecArgs = options.initArgs.includes("--skip-cli-update")
         ? options.initArgs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waypoint-codex",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "Make Codex better by default with stronger planning, code quality, reviews, tracking, and repo guidance.",
   "license": "MIT",
   "type": "module",

package/templates/.agents/skills/pr-review/SKILL.md

@@ -1,81 +1,71 @@
 ---
 name: pr-review
-description: Triage and close the review loop on an open PR after automated or human review has started. Use when a PR has review comments pending, when automated reviewers are still running, or when you need to wait for review completion, answer every inline comment, fix meaningful issues, push follow-up commits, and keep repeating until no new meaningful review findings remain.
+description: Run and close the full PR review loop with CodeRabbit and Codex reviewers. Use when a PR already has review activity or when you need to request, wait for, triage, fix, and re-request automated review until no meaningful issues remain and CI/CD is green.
 ---
 
-# PR Review
+# PR review
 
-Use this skill to drive the PR through review instead of treating review as a one-shot comment sweep.
+Use this skill to drive an open PR through reviewer and CI/CD convergence. This is a loop, not a one-shot comment sweep.
 
-## When Not To Use This Skill
+## When To Use
 
-- Skip it before a PR has active review or automated review in flight.
-- Skip it for the repo-internal closeout loop on an unpushed slice; use the normal review workflows instead.
+- Use when PR comments already exist (human or automated).
+- Use when CodeRabbit or Codex review is expected for the PR.
+- Use when CI/CD checks are part of merge readiness.
 
-## Step 1: Wait For Review To Settle
+## Core Loop
 
-- Check the PR's current review and CI status.
-- If CI is red or pending, inspect the failed check logs before triaging review comments so you do not chase comment fixes while a separate blocker is breaking the branch.
-- If automated review is still running, wait for it to finish instead of racing it.
-- Treat placeholder messages such as CodeRabbit's "review in progress" as unfinished state, not as a meaningful review result.
-- If an automated reviewer like CodeRabbit is still pending, in progress, or has not reached a green/completed check state yet, keep waiting before you conclude there are no findings.
-- Once the automated reviewer check turns green/completed, reread the review comments and threads because the real findings may only appear after the placeholder state clears.
-- If comments are still arriving, do not prematurely declare the loop complete.
-- For stacked or non-`main` PRs, explicitly compare the PR head against its base branch and make sure later fixes on the base branch have actually been merged or rebased forward. Do not assume a sibling/base PR fix is already present in the dependent PR.
-- Keep waiting as long as required. Do not interrupt or abandon the review loop just because CI, reviewers, or automated checks are taking a long time.
+Run this loop until exit criteria are satisfied.
 
-## Step 2: Read Every Review Comment
+1. Load PR state:
+- collect all current review threads and comments, including existing comments present before the skill started
+- collect CI/CD status for required checks
 
-- Read all open review comments, especially inline comments.
-- Group duplicates, but do not ignore any comment.
-- Distinguish between meaningful issues, optional suggestions, and comments that should be explicitly declined.
+2. Triage and act:
+- treat each reviewer finding as actionable unless it is clearly a false positive
+- fix all non-false-positive findings in code/docs/tests
+- if CI/CD has failures, fix those failures as part of the same loop
 
-## Step 3: Triage And Respond Inline
+3. Thread discipline for every addressed or skipped finding:
+- post an inline reply on that thread explaining the fix or why it is a false positive
+- resolve the thread after replying
 
-For every comment:
+4. Push and re-request automated review:
+- push commits
+- post comment: `@coderabbitai review`
+- post comment: `@codex review`
 
-- fix it if it is correct and in scope
-- explain clearly if you are declining it
-- reply inline where the comment lives instead of posting a disconnected summary comment
-- after pushing a fix, go back and answer the comment thread explicitly so the reviewer can see what changed
-- do not leave a comment thread silent just because the code was updated
+5. Wait for review/check updates:
+- wait up to 30 minutes total
+- check every 5 minutes using a sleep interval (`sleep 300`)
+- on each check, re-read both review and CI/CD status
+- if meaningful findings or CI/CD failures appear, continue the loop immediately
 
-Do not leave comments unanswered.
+## Exit Criteria
 
-## Step 4: Push The Next Round
+You may end the loop only when all are true:
 
-- Make the needed fixes.
-- rerun the relevant verification
-- if the PR is stacked, repeat the base-vs-head sanity check after pushes so you catch missing forward-merges before the next CI cycle
-- push follow-up commit(s)
-- after pushing, return to the PR and wait for the next round of CI, automated review, and human review comments before deciding whether the loop is complete
-- if CI or review is still in flight, keep waiting instead of assuming your last push ended the process
-- before declaring the PR clear or ready, make sure the required Waypoint reviewer agents for this slice have actually run and that their real findings, if any, were handled
+- no unresolved meaningful CodeRabbit findings remain
+- no unresolved meaningful Codex findings remain
+- every addressed or skipped finding has an inline reply and is resolved
+- CI/CD is green (or explicitly non-blocking per repo policy)
+- the latest reviewer rounds contain no meaningful new issues
 
-Stay in the loop until no new meaningful issues remain.
-Never cut the loop short by forcing a partial return from still-running review or verification systems.
-The loop is not complete while any meaningful review thread still lacks an inline response.
-The loop is also not complete if required Waypoint reviewer-agent passes for the current slice have not been run yet.
+## Required Behavior
 
-## Step 5: Close With A Crisp State Summary
+- Do not ignore existing comments that were already open when the skill was invoked.
+- Do not stop after one pass if reviewer bots are still producing new findings.
+- Do not mark false positives without a concrete reason in the inline reply.
+- Do not leave handled threads unresolved.
+- Do not declare completion while CI/CD is failing for actionable reasons.
 
-Summarize:
+## Output Contract
 
-- what was fixed
-- what was intentionally declined
-- what verification ran
-- whether the PR is clear or still waiting on reviewer response
+Before finishing, report:
 
-## Gotchas
-
-- Do not treat a placeholder like "review in progress" as a clean review result.
-- Do not leave comment threads silent just because the code changed. The reply is part of the workflow.
-- Do not assume stacked PR fixes have landed in the branch you are reviewing; compare against the actual base.
-- Do not leave the loop just because CI is slow. A pending review state is still unfinished.
-- Do not declare the PR clear if the required repo-level reviewer passes have not actually run.
-
-## Keep This Skill Sharp
-
-- Add new gotchas when the same PR-review failure mode, automation blind spot, or reviewer-state confusion keeps recurring.
-- Tighten the description if the skill fires before review has actually started or misses real prompts about "address these PR comments" or "close the loop on this PR."
-- If the workflow keeps repeating the same review-system quirks, preserve them in the skill instead of letting them stay as one-off chat lessons.
+- total loop rounds executed
+- fixes made for reviewer findings
+- false positives skipped with rationale
+- CI/CD failures fixed
+- links or identifiers for final reviewer rounds checked
+- final status: `clear` or `still blocked`

package/templates/.agents/skills/pr-review/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: "PR Review"
-  short_description: "Close the review loop on an active PR"
-  default_prompt: "Use $pr-review when a PR has active review comments or automated review in progress. Wait for review to settle, triage every comment, reply inline, fix meaningful issues, push follow-up commits, and repeat until no new meaningful findings remain."
+  short_description: "Close the review loop with CodeRabbit, Codex, and CI/CD"
+  default_prompt: "Use $pr-review: address all existing PR review findings, fix actionable CI/CD failures, reply inline and resolve each handled thread, push fixes, comment '@coderabbitai review' and '@codex review', then poll every 5 minutes for up to 30 minutes per round until no meaningful new issues remain."