gigaplan 0.1.0

package/README.md

@@ -0,0 +1,114 @@
+# gigaplan
+
+Review agent-authored implementation plans in a browser, styled as a proper
+review tool rather than a wall of terminal text. The agent writes a plain
+Markdown plan — never HTML — and gigaplan renders it into numbered, collapsible
+sections with per-step inline comments, a review-coverage sidebar, and a
+finish-your-review panel (Approve / Approve with comments / Request changes),
+then hands the structured feedback back to the agent to act on.
+
+The UI follows the "Atelier / Terminal" design system (warm-paper light theme,
+phosphor-terminal dark theme, Bricolage Grotesque + JetBrains Mono type) —
+see `skills/gigaplan/SKILL.md` for the review workflow and `public/chrome.css`
+for the theme itself.
+
+## Getting started
+
+gigaplan isn't published to npm yet, so for now it runs from a local checkout
+of this repo:
+
+```
+npm install        # also builds it — see the `prepare` script
+```
+
+Try it against any Markdown file:
+
+```
+node bin/gigaplan.js review path/to/plan.md
+```
+
+That opens your browser straight to the review page. Leave a few comments,
+pick a verdict, and submit — then, in a second terminal:
+
+```
+node bin/gigaplan.js poll path/to/plan.md
+```
+
+blocks until you do, then prints back exactly the compact-markdown feedback an
+agent would read. `gigaplan end path/to/plan.md` marks the session done
+afterward (the shared local server itself stays running independently — see
+Configuration below).
+
+Optionally, run `npm link` once if you'd rather type the bare `gigaplan`
+command than the `node bin/gigaplan.js` prefix.
+
+### Installing the skill
+
+The point of gigaplan is for an *agent* — any agent, not tied to one product —
+to drive this loop on your behalf: write the plan, open it for you, wait for
+your review, and revise based on your comments, looping until you approve it.
+Install `skills/gigaplan/SKILL.md` via skills.sh so it's picked up
+automatically, without you needing to invoke anything by name.
+`skills/gigaplan/SKILL.md` documents the exact workflow and CLI contract an
+agent follows — read it if you want to know precisely what happens under the
+hood.
+
+Once gigaplan is published, `npx -y gigaplan ...` per command replaces the
+local-checkout commands above — no local build needed, matching what the
+skill already documents.
+
+## How it works
+
+```
+agent writes plan.md (plain Markdown, never HTML)
+  -> npx -y gigaplan review <path>    opens a browser tab rendering the plan as
+                                       numbered sections (## headings), each with
+                                       per-item inline comments
+  -> reviewer comments on specific steps and/or leaves overall feedback, then
+     selects Approve / Request changes and submits
+  -> npx -y gigaplan poll <path>      blocks, then prints the review as compact markdown
+  -> agent revises plan.md and loops back to `review` (reopens the same tab) until approved
+  -> npx -y gigaplan end <path>       marks the session done
+```
+
+Live-reload: edit the plan file while the tab is open and it updates without a
+manual refresh. A comment anchored to a section whose text changed is flagged
+"content changed since this comment was left"; a comment on a deleted section is
+kept, not silently dropped, in a "Comments on removed content" area.
+
+## CLI
+
+```
+gigaplan review <path>   Open (or reuse) the browser review session for this plan file.
+gigaplan poll <path>     Block until a review is submitted; print it as compact markdown.
+gigaplan end <path>      Mark the review session done (the shared local server stays up;
+                         it shuts itself down after a period of inactivity).
+```
+
+Locally (pre-publish), that's `node bin/gigaplan.js <command>` unless you've
+`npm link`-ed it (see Getting started).
+
+## Configuration
+
+| Env var | Default | Purpose |
+| --- | --- | --- |
+| `GIGAPLAN_PORT` | `4873` | Port the shared local server binds to (loopback-only). |
+| `GIGAPLAN_IDLE_TIMEOUT_MS` | `1800000` (30 min) | How long the server stays up with no requests before it shuts itself down. |
+
+State (session records and the server's pid/port lock) lives in `~/.gigaplan/`.
+
+## Contributing
+
+```
+npm run typecheck # tsc --noEmit against both the server and client TypeScript
+npm test          # node:test, run directly against .ts sources via tsx
+npm run build     # compiles src/*.ts -> dist/, client/chrome.ts -> public/chrome.js
+```
+
+Read `CLAUDE.md` first — it covers the architecture (why the project is
+ESM-only, the two separate TypeScript compilations for server vs. browser
+code, the request flow through the server, how comment anchoring and
+live-reload reconciliation work) and what manual verification looks like for
+the parts of the codebase the test suite doesn't cover (the CLI process
+lifecycle and the browser UI have no automated coverage — changes there need
+an actual browser, not just a green type-check).

package/bin/gigaplan.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { main } from "../dist/cli.js";
+main();

package/dist/cli.js

@@ -0,0 +1,188 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as http from "node:http";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import open from "open";
+import { canonicalPlanPath, PORT, LONG_POLL_TIMEOUT_MS } from "./paths.js";
+import { readServerLock, getSession, bumpLastPolledReviewId } from "./session-store.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function printUsage() {
+    console.log([
+        "Usage: gigaplan <command> <path-to-plan.md>",
+        "",
+        "Commands:",
+        "  review <path>   Open (or reuse) the browser review session for this plan file",
+        "  poll <path>     Block until a review is submitted; print it as compact markdown",
+        "  end <path>      Mark the review session done",
+    ].join("\n"));
+}
+function requestJson(method, urlPath, body, timeoutMs = 10_000) {
+    return new Promise((resolve, reject) => {
+        const payload = body !== undefined ? JSON.stringify(body) : undefined;
+        const req = http.request({
+            host: "127.0.0.1",
+            port: PORT,
+            path: urlPath,
+            method,
+            timeout: timeoutMs,
+            headers: payload
+                ? { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) }
+                : undefined,
+        }, (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                const text = Buffer.concat(chunks).toString("utf8");
+                const status = res.statusCode ?? 0;
+                if (status === 204 || text.length === 0) {
+                    resolve({ status, body: undefined });
+                    return;
+                }
+                try {
+                    resolve({ status, body: JSON.parse(text) });
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        });
+        req.on("error", reject);
+        req.on("timeout", () => req.destroy(new Error("request timed out")));
+        if (payload)
+            req.write(payload);
+        req.end();
+    });
+}
+async function ensureServerRunning() {
+    const existing = readServerLock();
+    if (existing)
+        return;
+    const serverEntry = path.join(__dirname, "server.js");
+    const child = spawn(process.execPath, [serverEntry], {
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+    // Wait for the freshly spawned server to bind and write its lock file.
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline) {
+        if (readServerLock())
+            return;
+        await new Promise((r) => setTimeout(r, 100));
+    }
+    throw new Error("gigaplan server did not start in time");
+}
+async function cmdReview(rawPath) {
+    if (!rawPath) {
+        console.error("gigaplan review: missing <path-to-plan.md>");
+        process.exitCode = 1;
+        return;
+    }
+    const planPath = canonicalPlanPath(rawPath);
+    if (!fs.existsSync(planPath)) {
+        console.error(`gigaplan review: plan file not found: ${planPath}`);
+        process.exitCode = 1;
+        return;
+    }
+    await ensureServerRunning();
+    const { status, body } = await requestJson("POST", "/api/sessions", { planPath });
+    if (status !== 200) {
+        console.error(`gigaplan review: ${body.error ?? "failed to create session"}`);
+        process.exitCode = 1;
+        return;
+    }
+    await open(body.url);
+    console.log(`Opened for review: ${body.url}`);
+}
+function verdictTitle(verdict) {
+    if (verdict === "approve")
+        return "approved";
+    if (verdict === "request_changes")
+        return "request changes";
+    return "comment";
+}
+function formatReviewAsMarkdown(review) {
+    const lines = [];
+    lines.push(`# Review: ${verdictTitle(review.verdict)}`);
+    lines.push("");
+    lines.push("## Overall comment");
+    lines.push(review.globalComment.trim().length > 0 ? review.globalComment.trim() : "(none)");
+    if (review.comments.length > 0) {
+        lines.push("");
+        lines.push("## Comments");
+        for (const comment of review.comments) {
+            const breadcrumb = comment.headingBreadcrumb.join(" > ") || comment.excerpt || comment.blockId;
+            lines.push(`### On "${breadcrumb}"`);
+            if (comment.stale) {
+                lines.push("_(content at this location changed since this comment was left)_");
+            }
+            lines.push(comment.body);
+            lines.push("");
+        }
+    }
+    return lines.join("\n").trimEnd() + "\n";
+}
+async function cmdPoll(rawPath) {
+    if (!rawPath) {
+        console.error("gigaplan poll: missing <path-to-plan.md>");
+        process.exitCode = 1;
+        return;
+    }
+    const planPath = canonicalPlanPath(rawPath);
+    if (!readServerLock()) {
+        console.error("gigaplan poll: no gigaplan server is running; run `gigaplan review <path>` first");
+        process.exitCode = 1;
+        return;
+    }
+    const sessionKey = encodeURIComponent(planPath);
+    const since = getSession(planPath)?.lastPolledReviewId ?? 0;
+    for (;;) {
+        const { status, body } = await requestJson("GET", `/api/sessions/${sessionKey}/poll?since=${since}`, undefined, LONG_POLL_TIMEOUT_MS + 5000);
+        if (status === 204)
+            continue;
+        bumpLastPolledReviewId(planPath, body.reviewId);
+        process.stdout.write(formatReviewAsMarkdown(body));
+        return;
+    }
+}
+async function cmdEnd(rawPath) {
+    if (!rawPath) {
+        console.error("gigaplan end: missing <path-to-plan.md>");
+        process.exitCode = 1;
+        return;
+    }
+    const planPath = canonicalPlanPath(rawPath);
+    const sessionKey = encodeURIComponent(planPath);
+    const { status } = await requestJson("POST", `/api/sessions/${sessionKey}/end`, {});
+    if (status !== 200) {
+        console.error(`gigaplan end: no session found for ${planPath}`);
+        process.exitCode = 1;
+        return;
+    }
+    console.log(`Review session ended for ${planPath}`);
+}
+export function main() {
+    const [, , command, arg] = process.argv;
+    const run = async () => {
+        switch (command) {
+            case "review":
+                await cmdReview(arg);
+                break;
+            case "poll":
+                await cmdPoll(arg);
+                break;
+            case "end":
+                await cmdEnd(arg);
+                break;
+            default:
+                printUsage();
+                if (command)
+                    process.exitCode = 1;
+        }
+    };
+    run().catch((err) => {
+        console.error(String(err instanceof Error ? err.message : err));
+        process.exitCode = 1;
+    });
+}

package/dist/markdown.js

@@ -0,0 +1,196 @@
+import * as crypto from "node:crypto";
+import MarkdownIt from "markdown-it";
+const md = new MarkdownIt({ html: false, linkify: true });
+function isOpen(type) {
+    return type.endsWith("_open");
+}
+function isClose(type) {
+    return type.endsWith("_close");
+}
+function groupTopLevelBlocks(tokens) {
+    const groups = [];
+    let current = [];
+    let depth = 0;
+    for (const token of tokens) {
+        current.push(token);
+        if (isOpen(token.type)) {
+            depth++;
+        }
+        else if (isClose(token.type)) {
+            depth--;
+        }
+        if (depth === 0) {
+            groups.push(current);
+            current = [];
+        }
+    }
+    if (current.length > 0)
+        groups.push(current);
+    return groups;
+}
+function blockType(group) {
+    const first = group[0];
+    const raw = isOpen(first.type) ? first.type.slice(0, -"_open".length) : first.type;
+    // Indented (4-space) code blocks render the same as fenced ones; treat them alike.
+    return raw === "code_block" ? "fence" : raw;
+}
+const CHECKLIST_RE = /^\[([ xX])\]\s+(.*)$/s;
+function splitListIntoItemGroups(group) {
+    // Exclude the outer list_open/list_close tokens; groupTopLevelBlocks is
+    // depth-relative, so it happily regroups the inner tokens by list_item.
+    return groupTopLevelBlocks(group.slice(1, group.length - 1));
+}
+// markdown-it's renderer includes the <li>...</li> wrapper itself; the client
+// re-wraps each item in its own bullet/ordinal/checkbox markup instead of a
+// real <ul>/<ol>, and a bare <li> outside a list container still gets the
+// browser's default disc marker — so the wrapper has to come off here.
+function stripListItemWrapper(html) {
+    return html.replace(/^\s*<li[^>]*>\s*/, "").replace(/\s*<\/li>\s*$/, "");
+}
+function plainText(group) {
+    const parts = [];
+    for (const token of group) {
+        if (token.type === "inline" && token.children) {
+            for (const child of token.children) {
+                if (child.type === "text" || child.type === "code_inline") {
+                    parts.push(child.content);
+                }
+            }
+        }
+        else if (token.type === "fence" || token.type === "code_block") {
+            parts.push(token.content);
+        }
+    }
+    return parts.join(" ");
+}
+function normalize(text) {
+    return text.trim().replace(/\s+/g, " ");
+}
+function hashOf(text) {
+    return crypto.createHash("sha256").update(normalize(text)).digest("hex").slice(0, 6);
+}
+function excerptOf(text) {
+    const normalized = normalize(text);
+    return normalized.length > 80 ? `${normalized.slice(0, 80)}…` : normalized;
+}
+const HEADING_TAG_LEVEL = {
+    h1: 1,
+    h2: 2,
+    h3: 3,
+    h4: 4,
+    h5: 5,
+    h6: 6,
+};
+export function parseBlocks(source) {
+    const tokens = md.parse(source, {});
+    const groups = groupTopLevelBlocks(tokens);
+    const blocks = [];
+    const headingStack = [];
+    let nextId = 1;
+    for (const group of groups) {
+        const type = blockType(group);
+        if (type === "bullet_list" || type === "ordered_list") {
+            const listId = `l${nextId}`;
+            const listKind = type === "ordered_list" ? "ordered" : "bullet";
+            const startAttr = group[0].attrGet?.("start");
+            let ordinal = startAttr ? Number(startAttr) : 1;
+            const ancestorBreadcrumb = headingStack.map((h) => h.text);
+            for (const itemGroup of splitListIntoItemGroups(group)) {
+                const rawText = plainText(itemGroup);
+                const checklistMatch = CHECKLIST_RE.exec(rawText.trim());
+                const checklist = checklistMatch !== null;
+                const text = checklist ? checklistMatch[2] : rawText;
+                let html = stripListItemWrapper(md.renderer.render(itemGroup, md.options, {}));
+                if (checklist) {
+                    html = html.replace(/\[[ xX]\]\s*/, "");
+                }
+                blocks.push({
+                    id: `b${nextId++}`,
+                    hash: hashOf(text || html),
+                    type: "list_item",
+                    headingBreadcrumb: ancestorBreadcrumb,
+                    html,
+                    excerpt: excerptOf(text),
+                    listId,
+                    listKind,
+                    checklist,
+                    ...(listKind === "ordered" ? { ordinal: ordinal++ } : {}),
+                });
+            }
+            continue;
+        }
+        const text = plainText(group);
+        const html = md.renderer.render(group, md.options, {});
+        const first = group[0];
+        const headingLevel = first.type === "heading_open" ? HEADING_TAG_LEVEL[first.tag] : undefined;
+        if (headingLevel !== undefined) {
+            while (headingStack.length > 0 &&
+                headingStack[headingStack.length - 1].level >= headingLevel) {
+                headingStack.pop();
+            }
+        }
+        const ancestorBreadcrumb = headingStack.map((h) => h.text);
+        const headingBreadcrumb = headingLevel !== undefined ? [...ancestorBreadcrumb, normalize(text)] : ancestorBreadcrumb;
+        blocks.push({
+            id: `b${nextId++}`,
+            hash: hashOf(text || html),
+            type: type,
+            headingBreadcrumb,
+            html,
+            excerpt: excerptOf(text),
+            ...(headingLevel !== undefined ? { headingLevel } : {}),
+        });
+        if (headingLevel !== undefined) {
+            headingStack.push({ level: headingLevel, text: normalize(text) });
+        }
+    }
+    return blocks;
+}
+export function reconcileBlocks(oldBlocks, freshBlocks) {
+    const oldByHash = new Map();
+    for (const block of oldBlocks) {
+        const bucket = oldByHash.get(block.hash) ?? [];
+        bucket.push(block);
+        oldByHash.set(block.hash, bucket);
+    }
+    const claimedOldIds = new Set();
+    const claimedNewIndexes = new Set();
+    const result = new Array(freshBlocks.length);
+    // Pass 1: exact content match (block unchanged, possibly moved).
+    freshBlocks.forEach((fresh, index) => {
+        const candidates = oldByHash.get(fresh.hash);
+        if (candidates && candidates.length > 0) {
+            const old = candidates.shift();
+            claimedOldIds.add(old.id);
+            claimedNewIndexes.add(index);
+            result[index] = { ...fresh, id: old.id };
+        }
+    });
+    const unclaimedOld = oldBlocks.filter((b) => !claimedOldIds.has(b.id));
+    const unclaimedNewIndexes = freshBlocks
+        .map((_, index) => index)
+        .filter((index) => !claimedNewIndexes.has(index));
+    // Pass 2: positional match among what's left (block edited in place).
+    const stale = [];
+    const pairCount = Math.min(unclaimedOld.length, unclaimedNewIndexes.length);
+    for (let k = 0; k < pairCount; k++) {
+        const old = unclaimedOld[k];
+        const newIndex = unclaimedNewIndexes[k];
+        result[newIndex] = { ...freshBlocks[newIndex], id: old.id };
+        stale.push({ id: old.id, previousExcerpt: old.excerpt });
+    }
+    // Leftover new blocks are pure insertions; give them ids past any existing max.
+    const maxIdNum = Math.max(0, ...oldBlocks.map((b) => Number(b.id.slice(1)) || 0));
+    let nextId = maxIdNum + 1;
+    for (let k = pairCount; k < unclaimedNewIndexes.length; k++) {
+        const newIndex = unclaimedNewIndexes[k];
+        result[newIndex] = { ...freshBlocks[newIndex], id: `b${nextId++}` };
+    }
+    // Leftover old blocks were deleted; keep their comments addressable as orphaned.
+    const orphaned = unclaimedOld.slice(pairCount).map((b) => ({
+        id: b.id,
+        excerpt: b.excerpt,
+        headingBreadcrumb: b.headingBreadcrumb,
+    }));
+    return { blocks: result, stale, orphaned };
+}

package/dist/paths.js

@@ -0,0 +1,13 @@
+import * as os from "node:os";
+import * as path from "node:path";
+export const STATE_DIR = path.join(os.homedir(), ".gigaplan");
+export const STATE_FILE = path.join(STATE_DIR, "state.json");
+export const SERVER_LOCK_FILE = path.join(STATE_DIR, "server.json");
+export const DEFAULT_PORT = 4873;
+export const PORT = Number(process.env.GIGAPLAN_PORT) || DEFAULT_PORT;
+export const DEFAULT_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
+export const IDLE_TIMEOUT_MS = Number(process.env.GIGAPLAN_IDLE_TIMEOUT_MS) || DEFAULT_IDLE_TIMEOUT_MS;
+export const LONG_POLL_TIMEOUT_MS = 60_000;
+export function canonicalPlanPath(inputPath) {
+    return path.resolve(process.cwd(), inputPath);
+}

package/dist/render.js

@@ -0,0 +1,48 @@
+import * as path from "node:path";
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+// Guards against a code fence or comment containing a literal `</script>` sequence
+// from prematurely closing the embedded JSON island (see gigaplan/project-artifact
+// precedent: escape `<` as < inside any JSON blob placed inside a <script> tag).
+function embedJson(data) {
+    return JSON.stringify(data).replace(/</g, "\\u003c");
+}
+function planTitle(planPath, blocks) {
+    const firstHeading = blocks.find((b) => b.headingLevel === 1);
+    if (firstHeading)
+        return firstHeading.headingBreadcrumb[firstHeading.headingBreadcrumb.length - 1];
+    return path.basename(planPath);
+}
+export function renderSessionPage(sessionKey, planPath, blocks) {
+    const title = escapeHtml(planTitle(planPath, blocks));
+    const initialData = embedJson({ sessionKey, planPath, blocks });
+    // client/chrome.ts builds the entire visible page (top bar, sections, sidebar,
+    // finish panel) from the JSON island below — this shell only supplies the
+    // theme tokens, fonts, and mount point.
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>${title} · gigaplan</title>
+<link rel="stylesheet" href="/public/chrome.css" />
+<script>
+  (function () {
+    var dark = window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches;
+    document.documentElement.setAttribute("data-theme", dark ? "dark" : "light");
+  })();
+</script>
+</head>
+<body>
+<div id="gp-app" class="gp-app"></div>
+<script type="application/json" id="gigaplan-data">${initialData}</script>
+<script type="module" src="/public/chrome.js"></script>
+</body>
+</html>
+`;
+}

package/dist/review-store.js

@@ -0,0 +1,84 @@
+const runtimes = new Map();
+function getRuntime(planPath) {
+    let runtime = runtimes.get(planPath);
+    if (!runtime) {
+        runtime = {
+            blocks: [],
+            reviews: [],
+            nextReviewId: 0,
+            waiters: [],
+            lastReconciliation: { stale: new Map(), orphaned: [] },
+        };
+        runtimes.set(planPath, runtime);
+    }
+    return runtime;
+}
+export function setBlocks(planPath, blocks) {
+    getRuntime(planPath).blocks = blocks;
+}
+export function getBlocks(planPath) {
+    return getRuntime(planPath).blocks;
+}
+export function applyReconciliation(planPath, result) {
+    const runtime = getRuntime(planPath);
+    runtime.blocks = result.blocks;
+    runtime.lastReconciliation = {
+        stale: new Map(result.stale.map((s) => [s.id, s.previousExcerpt])),
+        orphaned: result.orphaned,
+    };
+}
+export function getLastReconciliation(planPath) {
+    return getRuntime(planPath).lastReconciliation;
+}
+export function submitReview(planPath, verdict, globalComment, comments) {
+    const runtime = getRuntime(planPath);
+    const blockById = new Map(runtime.blocks.map((b) => [b.id, b]));
+    const staleIds = runtime.lastReconciliation.stale;
+    const enriched = comments.map((c) => {
+        const block = blockById.get(c.blockId);
+        return {
+            blockId: c.blockId,
+            headingBreadcrumb: block?.headingBreadcrumb ?? [],
+            excerpt: block?.excerpt ?? "",
+            body: c.body,
+            stale: staleIds.has(c.blockId),
+        };
+    });
+    const review = {
+        reviewId: ++runtime.nextReviewId,
+        verdict,
+        globalComment,
+        comments: enriched,
+        submittedAt: new Date().toISOString(),
+    };
+    runtime.reviews.push(review);
+    runtime.lastReconciliation = { stale: new Map(), orphaned: [] };
+    const waiters = runtime.waiters.splice(0, runtime.waiters.length);
+    for (const waiter of waiters) {
+        clearTimeout(waiter.timer);
+        waiter.resolve(review);
+    }
+    return review;
+}
+export function latestReview(planPath) {
+    const runtime = getRuntime(planPath);
+    return runtime.reviews[runtime.reviews.length - 1];
+}
+export function pollReview(planPath, sinceReviewId, timeoutMs) {
+    const runtime = getRuntime(planPath);
+    const existing = runtime.reviews.find((r) => r.reviewId > sinceReviewId);
+    if (existing)
+        return Promise.resolve(existing);
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            const index = runtime.waiters.findIndex((w) => w.resolve === resolveOnce);
+            if (index !== -1)
+                runtime.waiters.splice(index, 1);
+            resolve(null);
+        }, timeoutMs);
+        function resolveOnce(review) {
+            resolve(review);
+        }
+        runtime.waiters.push({ resolve: resolveOnce, timer });
+    });
+}