@brainervirus/workit-cursor 0.6.1 → 0.7.1

package/.cursor-plugin/plugin.json

@@ -2,9 +2,12 @@
   "name": "workit",
   "displayName": "Workit",
   "description": "OpenCode-style verify, PR, changelog, commit, and session handoff for Cursor",
-  "version": "0.6.1",
-  "skills": "../skills/",
-  "rules": "../rules/",
-  "mcpServers": "../mcp.json",
-  "hooks": "../hooks/hooks-cursor.json"
+  "version": "0.7.1",
+  "skills": [
+    "skills/",
+    "vendor/superpowers/skills/"
+  ],
+  "rules": "rules/",
+  "mcpServers": "mcp.json",
+  "hooks": "hooks/hooks-cursor.json"
 }

package/assets/templates/execution-contract.md

@@ -0,0 +1,58 @@
+Load `using-superpowers`, `subagent-driven-development`, `test-driven-development`, and `verification-before-completion` through OpenCode's `skill` tool. Implement the existing plan; do not re-plan.
+
+**Spec:** <SPEC_PATH>
+**Plan:** <PLAN_PATH>
+**Branch:** <BRANCH>
+**SDD:** `<SDD_DIR>`
+
+## Hard gates
+
+- The parent is coordinator-only: it does not edit product code or perform delegated exploration.
+- Never use a worktree. Branch changes are in-place through `workflow_branch_setup` on `feature/*` or `bugfix/*`; never commit on protected branches.
+- Working state, briefs, ledgers, and review diffs live only under gitignored `<SDD_DIR>` in `docs/<slug>/sdd/` and use `workflow_sdd_*` tools.
+- Use native `todowrite` for visible task state as well as the gitignored ledger.
+- Use native `question` for branch/stash choices and guarded external mutations; call mutation tools only after approval with `confirmed: true` (grounded in the recorded NativeChoiceEvidence).
+- Flow-tool confirmations are never agent-typed booleans and never caller-supplied evidence objects: on OpenCode the plugin records the user's native-`question` answer as a host-observed one-use receipt (`attested: true`, `callID`, `selectedLabel`, `recordedAt`) consumed by `workflow_spec_approve` / `workflow_plan_approve` / `workflow_plan_menu` — no evidence argument exists, and delegated worker status comes from host session parentage (`parentID`), never a caller `role` field. On Cursor, confirmations are policy-only (`attested: false`) and subagent-driven execution is rejected as unsupported.
+- On Cursor, for every repository-scoped `workflow_*` call, pass the active Cursor workspace as `workspace_root`; never rely on the MCP process default.
+- Use native `task` with only the built-in `explore` and `general` agents.
+
+## Flow gates (HARD)
+
+- `wk-implement` refuses to run unless the plan is `approved` (flow.json) and the post-plan menu was presented.
+- `wk-handoff` refuses to run unless both spec and plan are `approved`.
+- Sequence is enforced by tools: `workflow_spec_approve`, `workflow_plan_approve`, `workflow_plan_menu` — never skip a step (the spec/plan self-review runs automatically inside the transition; only the final approval asks for your confirmation).
+
+## Setup
+
+0. Call `workflow_docs_validate` with the linked spec/plan paths. Hard-fail on any error before todos or branch setup.
+1. Call `workflow_sdd_context` with `<PLAN_PATH>` and initialize `todowrite` from returned tasks.
+2. Call `workflow_plan_tasks`; cache each top-level task's `section_text`.
+3. Mark IDs in `completed_task_ids` completed and never redispatch them.
+4. Call `workflow_resolve_branch`, then show the current branch, target branch, and stash behavior before any in-place checkout/setup mutation.
+5. Always use `question`: for a clean tree ask whether to proceed or cancel; for a dirty tree add the stash choice and describe what will be stashed.
+6. Call `workflow_branch_setup` with `confirmed: true` only after approval.
+
+## Remaining-task loop
+
+For each top-level task absent from `completed_task_ids`:
+
+1. Mark it `in_progress` with `todowrite`.
+2. Create a working-state brief with `workflow_sdd_task_brief` and `confirmed: true`.
+3. Delegate read-only discovery, when needed, to an `explore` agent. Delegate implementation to a fresh `general` agent. Product changes follow TDD.
+4. Create a working-state diff with `workflow_sdd_review_package` and `confirmed: true`.
+5. Delegate spec-compliance review and code-quality review to separate `general` agents.
+6. **Blocking** findings (Critical, Important, or spec-compliance) may trigger at most **two** fix+re-review rounds per task. **Advisory** findings (Minor, style, YAGNI, taste) never pause the loop — append them to `<SDD_DIR>/advisories.md`.
+7. Append the validated ledger entry with `workflow_sdd_append_progress` and `confirmed: true`; mark the todo completed.
+
+## Final gate
+
+Run a separate full-branch code review, then `workflow_verify`. Present the full `<SDD_DIR>/advisories.md` roll-up once, then use native `question` so the user can choose which advisory items to fix, discuss, or discard. Report exact check results and never infer success. Use `workflow_git_context` for a commit preview and load `wk-commit` through `skill` for an approved commit. If working state contains a stash reference, preview reapplication through `question`, then call `workflow_branch_setup` with `confirmed: true` after approval.
+
+## Task order
+
+<TASK_LIST>
+
+## Quality gate (HARD)
+
+- Specs/plans are written from `templates/spec-template.md` / `templates/plan-template.md`.
+- After `workflow_docs_validate`, surface `quality` findings (spec scan). Hard findings (missing required section, missing CA-XX) block task start unless the user explicitly waives them. Warnings are advisory.

package/assets/templates/greeting.md

@@ -0,0 +1 @@
+{{greetingText}}

package/assets/templates/headers.md

@@ -0,0 +1,3 @@
+## Adjunto capturas
+
+## Archivos adjuntos

package/assets/templates/hygiene/.editorconfig

@@ -0,0 +1,8 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2

package/assets/templates/hygiene/.gitattributes

@@ -0,0 +1,3 @@
+* text=auto
+*.md text
+*.bat text eol=crlf

package/assets/templates/hygiene/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+### Changed
+
+### Fixed

package/assets/templates/hygiene/CONTRIBUTING.md

@@ -0,0 +1,3 @@
+# Contributing
+
+<!-- How to report issues, propose changes, and the review process. -->

package/assets/templates/hygiene/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) <YEAR> <HOLDER>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/assets/templates/hygiene/README.md

@@ -0,0 +1,3 @@
+# <PROJECT>
+
+<!-- Describe the project: what it does, how to run it, how to contribute. -->

package/assets/templates/issue-update.md

@@ -0,0 +1,6 @@
+# Actualización
+{{greetingSection}}
+{{projectSection}}
+{{userNotesSection}}
+{{progressSection}}
+{{gitCommitsSection}}

package/assets/templates/plan-template.md

@@ -0,0 +1,25 @@
+# <Feature> Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Spec:** `docs/<slug>/spec.md`
+**Branch:** `feature/<slug>`
+
+**Goal:** <one sentence>
+
+## Global Constraints
+
+- <project-wide requirements, one line each>
+
+---
+
+### Task N: <Component>
+
+- [ ] **Step 1: <action>**
+
+<!-- per-task criteria: how this task is verified -->
+**Criteria:** <verifiable check>
+
+| Status | Task |
+| --- | --- |
+| pending | N: <Component> |

package/assets/templates/spec-template.md

@@ -0,0 +1,51 @@
+# Spec: <feature>
+
+**Branch:** `feature/<slug>`
+
+## Context
+
+<!-- Why does this exist? What problem does it solve? 1-3 sentences. -->
+
+## Goals
+
+- <!-- measurable, one per bullet -->
+
+## Non-goals
+
+- <!-- explicitly out of scope -->
+
+## Architecture
+
+<!-- REQUIRED if this spec has flows or architecture: render a mermaid diagram (workflow_present_flow). -->
+```mermaid
+flowchart TD
+  A[Start] --> B[Step]
+```
+
+<!-- REQUIRED if this spec touches UI: render an ASCII wireframe (workflow_present_ascii). -->
+```text
+┌──────────────┐
+│ Header       │
+└──────────────┘
+```
+
+## Data flow / contracts
+
+<!-- REQUIRED when there is a glossary, scope comparison, or contracts: use markdown tables. -->
+| Term | Meaning |
+| --- | --- |
+| <term> | <meaning> |
+
+## Acceptance criteria
+
+<!-- REQUIRED: enumerable, each verifiable. Numbered CA-01, CA-02, ... -->
+- CA-01 …
+- CA-02 …
+
+## Decisions
+
+- D-01 …
+
+## Future work
+
+- …

package/assets/templates/superpowers-doc-contract.md

@@ -0,0 +1,70 @@
+# Superpowers document contract
+
+Use OpenCode's native `question` for every bounded user choice. Give concise choices and allow a custom answer; if the tool is unavailable, ask one concise plain-text question. Use `skill` to load workflow and Superpowers skills, `todowrite` for task state, and `task` for delegated work.
+
+## Tracked document layout
+
+| Document | Path |
+| --- | --- |
+| Spec | `docs/<slug>/spec.md` |
+| Plan | `docs/<slug>/plan.md` |
+| SDD state | `docs/<slug>/sdd/` |
+
+An optional human mirror may live at `docs/specs/<same-basename>.md`; when present, keep its branch identical.
+
+Specs require:
+
+```markdown
+**Branch:** `feature/<slug>`
+```
+
+Plans require:
+
+```markdown
+**Spec:** `docs/<slug>/spec.md`
+**Branch:** `feature/<slug>`
+```
+
+`bugfix/<slug>` is also valid. Never use `main`, `develop`, `master`, or `prod`. Use plain backtick paths. Top-level headings are exactly `### Task N: Title`; steps use `- [ ] **Step N:** ...`; task headings never appear inside fences.
+
+Before writing **Branch:** into a new spec or plan, call `workflow_docs_branch` and write the returned `branch` verbatim. When `action` is `keep`, use the current feature/bugfix branch. When `action` is `create_from_develop` or `create_from_base`, create the branch only through `workflow_branch_setup`; it uses the configured workspace/global target branch.
+
+## Execution and handoff
+
+- Implementation uses `wk-implement` and subagent-driven development, with native `todowrite` and `task`.
+- Commits use `wk-commit` after its native `question` confirmation.
+- Continuation uses `wk-handoff`, whose `workflow_handoff_session` creates and seeds the OpenCode session automatically.
+- Never use worktrees. Resolve the declared branch with `workflow_resolve_branch`, preview dirty-tree stash choices with `question`, and apply an approved in-place checkout through `workflow_branch_setup` with `confirmed: true` (grounded in the recorded NativeChoiceEvidence).
+- Flow-tool confirmations are never agent-typed booleans and never caller-supplied evidence objects: on OpenCode the plugin records the user's native-`question` answer as a host-observed one-use receipt (`attested: true`, `callID`, `selectedLabel`, `recordedAt`) consumed by `workflow_spec_approve` / `workflow_plan_approve` / `workflow_plan_menu` — no evidence argument exists, and delegated worker status comes from host session parentage (`parentID`), never a caller `role` field. On Cursor, confirmations are policy-only (`attested: false`) and subagent-driven execution is rejected as unsupported.
+- Keep all SDD state under the gitignored `docs/<slug>/sdd/`; use `workflow_sdd_context` and the registered `workflow_sdd_*` tools.
+- After implementation, use `question` before an approved stash reapply through `workflow_branch_setup` with `confirmed: true`.
+
+## YouTrack content
+
+Chat follows the user's language. YouTrack task comments are Spanish (`es-CL`) and use `workflow_youtrack_draft` followed by reviewed `workflow_youtrack_post` with `confirmed: true`. Preserve the user's paragraph voice; do not inject commits, file paths, or robotic bullet reports.
+
+## Final self-check
+
+Before handoff, call `workflow_docs_validate` on the linked spec/plan pair. Hard-fail on any error; never offer execution when validation fails.
+
+Before handoff, verify the saved spec path, plan path, declared branch, top-level task numbering, and workflow-managed SDD directory through the registered read-only workflow tools. Report structured failures; never infer success.
+
+## Post-plan execution choice
+
+After saving a plan, call `workflow_docs_validate` on the spec/plan pair. On failure, stop and fix docs — do not offer execution.
+
+On success, use native `question` / Cursor `AskQuestion` with exactly these options (no stay, no A/B/C prose duplicate):
+
+1. Subagent-driven → load `wk-implement`
+2. Inline → execute in this session
+3. Handoff → load `wk-handoff` (new session only)
+4. Review spec first
+5. Review plan first
+
+Never emit Superpowers text beginning “Two execution options”.
+
+- Specs/plans must follow `templates/spec-template.md` / `templates/plan-template.md` (mandated diagrams, tables, CA-XX).
+
+## Doc delivery
+
+When delivering a spec or plan, use a clickable markdown link (\`[spec.md](docs/<slug>/spec.md)\`) and a 3-5 bullet summary of the content (Context, Goals, key decisions, status). Never reference docs with backtick-only paths.

package/dist/cursor-session-start.js

@@ -0,0 +1,351 @@
+#!/usr/bin/env node
+
+// packages/workit-cursor/hooks/session-start.ts
+import { existsSync, readFileSync } from "node:fs";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// packages/workit-core/src/core/logger.ts
+import { appendFileSync, mkdirSync, readdirSync, unlinkSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+var REDACTED = "[REDACTED]";
+var DEFAULT_MAX_RATE = 20;
+var DEFAULT_RATE_WINDOW_MS = 1000;
+var DEFAULT_MAX_FIELD_LENGTH = 200;
+var DEFAULT_MAX_STACK_LINES = 30;
+var DAY_FILE = /^workit-\d{4}-\d{2}-\d{2}\.jsonl$/;
+var RETAINED_DAYS = 7;
+var SECRET_VALUE = /\b(?:Bearer|Basic|Digest|Token)\s+\S+/gi;
+var KEY_EQ_VALUE = /\b([A-Za-z0-9_-]*(?:token|secret|password|passwd|apikey|api[_-]?key|authorization|credential|bearer)[A-Za-z0-9_-]*)([:=]\s*).+/gi;
+var URL_QUERY = /(https?:\/\/[^?#\s]+)\?[^#\s]*/g;
+var splitKey = (key) => key.split(/[_-]+|(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/).map((word) => word.toLowerCase());
+var SENSITIVE_WORDS = new Set([
+  "token",
+  "secret",
+  "password",
+  "passwd",
+  "authorization",
+  "credential",
+  "credentials",
+  "cookie",
+  "api",
+  "apikey",
+  "apitoken",
+  "accesstoken",
+  "clientsecret",
+  "refreshtoken",
+  "key",
+  "bearer",
+  "prompt",
+  "message",
+  "messages",
+  "content",
+  "body",
+  "args",
+  "argument",
+  "result",
+  "results",
+  "output",
+  "issue",
+  "description",
+  "summary",
+  "payload",
+  "script",
+  "command",
+  "text",
+  "query"
+]);
+var STACK_WORDS = new Set(["stack", "stacktrace", "trace"]);
+var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var resolveStateDir = () => {
+  const override = process.env.WORKFLOW_TOOLKIT_STATE;
+  if (override)
+    return override;
+  const home = os.homedir();
+  if (process.env.XDG_STATE_HOME)
+    return path.join(process.env.XDG_STATE_HOME, "workit");
+  switch (os.platform()) {
+    case "darwin":
+      return path.join(home, "Library", "Application Support", "workit");
+    case "win32":
+      return path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "workit");
+    default:
+      return path.join(process.env.HOME ?? home, ".local", "state", "workit");
+  }
+};
+var homePattern = new RegExp(`${escapeRegExp(os.homedir())}(?=[/\\\\]|$)|\\$HOME(?=[/\\\\]|$)`, "g");
+var applyPatterns = (value) => {
+  let out = value;
+  out = out.replace(SECRET_VALUE, REDACTED);
+  out = out.replace(KEY_EQ_VALUE, "$1$2[REDACTED]");
+  out = out.replace(URL_QUERY, "$1?[REDACTED]");
+  out = out.replace(homePattern, "~");
+  if (process.platform === "win32")
+    out = out.replace(/\\/g, "/");
+  return out;
+};
+var redactString = (value, options) => {
+  const out = applyPatterns(value);
+  if (out.length > options.maxFieldLength) {
+    return `${out.slice(0, options.maxFieldLength)}…`;
+  }
+  return out;
+};
+var boundStack = (value, options) => {
+  if (typeof value !== "string")
+    return redact(value, options);
+  const lines = value.split(`
+`);
+  const kept = lines.slice(0, options.maxStackLines).map(applyPatterns);
+  const dropped = lines.length - kept.length;
+  const body = dropped > 0 ? [...kept, `    ... ${dropped} more`] : kept;
+  return body.join(`
+`);
+};
+var redact = (value, options = DEFAULT_OPTIONS) => {
+  if (value === null || value === undefined)
+    return null;
+  if (typeof value === "boolean" || typeof value === "number")
+    return value;
+  if (typeof value === "string")
+    return redactString(value, options);
+  if (value instanceof Date)
+    return value.toISOString();
+  if (Array.isArray(value))
+    return value.map((entry) => redact(entry, options));
+  if (typeof value === "object") {
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+      const words = splitKey(key);
+      if (words.some((word) => STACK_WORDS.has(word)))
+        out[key] = boundStack(entry, options);
+      else if (words.some((word) => SENSITIVE_WORDS.has(word)))
+        out[key] = REDACTED;
+      else
+        out[key] = redact(entry, options);
+    }
+    return out;
+  }
+  return null;
+};
+var DEFAULT_OPTIONS = {
+  maxFieldLength: DEFAULT_MAX_FIELD_LENGTH,
+  maxStackLines: DEFAULT_MAX_STACK_LINES
+};
+var dailyFileName = (date) => {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `workit-${y}-${m}-${d}.jsonl`;
+};
+var pruneOldFiles = (dir) => {
+  try {
+    const files = readdirSync(dir).filter((name) => DAY_FILE.test(name)).sort().reverse();
+    for (const file of files.slice(RETAINED_DAYS)) {
+      try {
+        unlinkSync(path.join(dir, file));
+      } catch {}
+    }
+  } catch {}
+};
+var createLogger = (options = {}) => {
+  const stateDir = options.stateDir ?? resolveStateDir();
+  const logDir = path.join(stateDir, "logs");
+  const now = options.now ?? (() => new Date);
+  const maxRate = options.maxRate ?? DEFAULT_MAX_RATE;
+  const rateWindowMs = options.rateWindowMs ?? DEFAULT_RATE_WINDOW_MS;
+  const redactOptions = {
+    maxFieldLength: options.maxFieldLength ?? DEFAULT_MAX_FIELD_LENGTH,
+    maxStackLines: options.maxStackLines ?? DEFAULT_MAX_STACK_LINES
+  };
+  let windowStart = 0;
+  const windowCounts = { debug: 0, info: 0, warn: 0, error: 0 };
+  const emit = (level, message, context) => {
+    const date = now();
+    const elapsed = date.getTime() - windowStart;
+    if (elapsed >= rateWindowMs || windowStart === 0) {
+      windowStart = date.getTime();
+      windowCounts.debug = 0;
+      windowCounts.info = 0;
+      windowCounts.warn = 0;
+      windowCounts.error = 0;
+    }
+    windowCounts[level] += 1;
+    if (windowCounts[level] > maxRate)
+      return;
+    let event = null;
+    try {
+      event = {
+        level,
+        time: date.toISOString(),
+        message: redactString(message, redactOptions),
+        context: redact(context ?? {}, redactOptions)
+      };
+      const line = `${JSON.stringify(event)}
+`;
+      mkdirSync(logDir, { recursive: true, mode: 448 });
+      appendFileSync(path.join(logDir, dailyFileName(date)), line, { mode: 384 });
+      pruneOldFiles(logDir);
+    } catch {
+      try {
+        event = {
+          level,
+          time: date.toISOString(),
+          message: redactString(message, redactOptions),
+          context: { redaction_failed: true }
+        };
+        mkdirSync(logDir, { recursive: true, mode: 448 });
+        appendFileSync(path.join(logDir, dailyFileName(date)), `${JSON.stringify(event)}
+`, {
+          mode: 384
+        });
+      } catch {}
+    }
+    for (const sink of [options.appLog, options.stderr]) {
+      if (!sink)
+        continue;
+      if (!event)
+        continue;
+      try {
+        sink(event);
+      } catch {}
+    }
+  };
+  return {
+    debug: (message, context) => emit("debug", message, context),
+    info: (message, context) => emit("info", message, context),
+    warn: (message, context) => emit("warn", message, context),
+    error: (message, context) => emit("error", message, context),
+    guard: (name, fn) => {
+      try {
+        return fn();
+      } catch (err) {
+        emit("warn", "detector_failed", {
+          detector: name,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        return;
+      }
+    }
+  };
+};
+
+// packages/workit-core/src/core/boundary.ts
+var EVENT = {
+  initialization: "initialization",
+  provenance: "provenance",
+  assets: "assets",
+  configurationSource: "configuration_source",
+  hooks: "hooks",
+  mcpConnection: "mcp_connection",
+  migration: "migration",
+  installSteps: "install_steps",
+  uncaughtFailure: "uncaught_failure",
+  toolsFailed: "tools_failed",
+  doctor: "doctor"
+};
+var errorDetail = (err) => {
+  if (err instanceof Error) {
+    return { error_name: err.name, error: err.message };
+  }
+  return { error_name: "unknown", error: String(err) };
+};
+
+// packages/workit-core/src/core/config.ts
+var diagnosticLogger;
+var setDiagnosticLogger = (logger) => {
+  diagnosticLogger = logger;
+};
+var PRESETS = {
+  gitflow: {
+    allowed: ["feature/*", "bugfix/*", "hotfix/*", "release/*"],
+    protected: ["main", "develop", "master", "prod", "production"]
+  },
+  "github-flow": { allowed: ["*"], protected: ["main"] },
+  "trunk-based": { allowed: ["*"], protected: ["main"] },
+  custom: { allowed: [], protected: [] }
+};
+var DEFAULTS = {
+  locale: "en",
+  localeOptions: ["en", "es-CL", "es-MX", "es-AR", "pt-BR"],
+  timezone: "America/Santiago",
+  branchPolicy: {
+    preset: "gitflow",
+    allowed: [...PRESETS.gitflow.allowed],
+    protected: [...PRESETS.gitflow.protected]
+  }
+};
+
+// packages/workit-cursor/hooks/session-start.ts
+var logger = createLogger({
+  stderr: (event) => process.stderr.write(`${JSON.stringify(event)}
+`)
+});
+var hookDir = path2.dirname(fileURLToPath(import.meta.url));
+var pluginDir = path2.resolve(hookDir, "..");
+var marker = path2.join(pluginDir, ".workflow-toolkit-root");
+setDiagnosticLogger(logger);
+logger.info(EVENT.initialization, { host: "cursor-hook", hook_dir: hookDir });
+var resolveRepoRoot = () => {
+  if (process.env.WORKFLOW_TOOLKIT_ROOT && existsSync(path2.join(process.env.WORKFLOW_TOOLKIT_ROOT, "templates"))) {
+    return process.env.WORKFLOW_TOOLKIT_ROOT;
+  }
+  if (existsSync(marker)) {
+    return readFileSync(marker, "utf8").replace(/\n+$/, "");
+  }
+  const ownAssets = path2.join(pluginDir, "assets");
+  if (existsSync(path2.join(ownAssets, "templates"))) {
+    return ownAssets;
+  }
+  return path2.resolve(hookDir, "../../workit-core");
+};
+var body = null;
+var repoRoot = resolveRepoRoot();
+try {
+  const contract = path2.join(repoRoot, "templates", "superpowers-doc-contract.md");
+  if (existsSync(contract))
+    body = readFileSync(contract, "utf8");
+} catch (err) {
+  logger.error(EVENT.hooks, { boundary: "session-start", root: repoRoot, ...errorDetail(err) });
+  body = null;
+}
+if (body === null) {
+  process.stdout.write(`{}
+`);
+  process.exit(0);
+}
+var context = `<workflow-toolkit-askquestion-hard-gate>
+HARD-GATE: Any user choice with options → call Cursor AskQuestion directly with workflow-specific copy. NEVER A/B/C in chat. Overrides Superpowers brainstorming conversational options.
+</workflow-toolkit-askquestion-hard-gate>
+
+<workflow-toolkit-visual-companion>
+HARD-GATE: NEVER offer Superpowers visual companion or open a browser tab. For UI wireframes use workflow_present_ascii; for flows use workflow_present_flow. Overrides Superpowers brainstorming visual companion offer.
+</workflow-toolkit-visual-companion>
+
+<workflow-toolkit-no-worktrees>
+HARD-GATE: NEVER using-git-worktrees or git worktree. In-place feature/* or bugfix/* checkout only via workflow_resolve_branch + workflow_branch_setup. Dirty tree → native AskQuestion before checkout.
+</workflow-toolkit-no-worktrees>
+
+<workflow-toolkit-sdd-path>
+HARD-GATE: NEVER .superpowers/sdd. ALWAYS workflow_sdd_context with plan_path first — resolves canonical docs/<slug>/sdd/ and creates nothing (no empty ledger; progress.md appears only on the first confirmed append). workflow_sdd_task_brief, workflow_sdd_review_package, workflow_sdd_append_progress only.
+</workflow-toolkit-sdd-path>
+
+<workflow-toolkit-todowrite>
+HARD-GATE: After workflow_sdd_context, call Cursor TodoWrite with returned todos (merge: false). SDD ledger is persistence — TodoWrite is the native task list UI. Keep in_progress/completed in sync each task.
+</workflow-toolkit-todowrite>
+
+<workflow-toolkit-superpowers-doc-contract>
+${body}
+</workflow-toolkit-superpowers-doc-contract>
+
+<workflow-toolkit-reminder>
+HARD-GATE: Bounded user choices → call Cursor AskQuestion directly (never A/B/C or 1/2/3 lists in prose). After a plan is approved → AskQuestion menu with: Subagent-driven, Inline, Handoff (new session only), Review spec first, Review plan first. Tools with confirmed → call them; never fabricate results.
+Delivering docs → clickable markdown link (docs/<slug>/spec.md) + 3-5 bullet summary.
+</workflow-toolkit-reminder>`;
+process.stdout.write(JSON.stringify({ additional_context: context }, null, 2) + `
+`);
+process.exit(0);
+export {
+  logger
+};