@harness-engineering/cli 1.8.0 → 1.8.1

package/dist/agents/skills/gemini-cli/initialize-harness-project/SKILL.md

@@ -0,0 +1,224 @@
+# Initialize Harness Project
+
+> Scaffold a new harness-compliant project or migrate an existing project to the next adoption level. Assess current state, configure personas, generate AGENTS.md, and validate the result.
+
+## When to Use
+
+- Starting a brand new project that should be harness-managed from day one
+- Migrating an existing project to harness for the first time
+- Upgrading an existing harness project from one adoption level to the next (basic to intermediate, intermediate to advanced)
+- When `on_project_init` triggers fire
+- NOT when the project is already at the desired adoption level (use harness-onboarding to orient instead)
+- NOT when adding a single component to an existing harness project (use add-harness-component)
+- NOT when the project has no clear owner or maintainer — harness setup requires someone to own the constraints
+
+## Process
+
+### Phase 1: ASSESS — Determine Current State
+
+1. **Check for existing harness configuration.** Look for `.harness/` directory, `AGENTS.md`, `harness.yaml`, and any skill definitions. Their presence determines whether this is a new project or a migration.
+
+2. **For new projects:** Gather project context — language, framework, test runner, build tool. Ask the human if any of these are undecided. Do not assume defaults.
+
+3. **For existing projects:** Run `harness validate` to see what is already configured and what is missing. Read `AGENTS.md` if it exists. Identify the current adoption level:
+   - **Basic:** Has `AGENTS.md` and `harness.yaml` with project metadata. No layers, no skills, no dependency constraints.
+   - **Intermediate:** Has layers defined, dependency constraints between layers, at least one custom skill. `harness check-deps` runs and passes.
+   - **Advanced:** Has full persona configuration, custom skills for the team's workflows, state management, learnings capture, and CI integration for `harness validate`.
+
+4. **Recommend the target adoption level.** For new projects, start with basic unless the team has harness experience. For existing projects, recommend one level up from current. Present the recommendation and wait for confirmation.
+
+### Phase 2: SCAFFOLD — Generate Project Structure
+
+1. **Run `harness init` with the appropriate flags:**
+   - New basic project: `harness init --level basic --framework <framework>`
+   - New intermediate project: `harness init --level intermediate --framework <framework>`
+   - Migration to intermediate: `harness init --level intermediate --migrate`
+   - Migration to advanced: `harness init --level advanced --migrate`
+
+2. **Review generated files.** `harness init` creates:
+   - `harness.yaml` — Project configuration (name, stack, adoption level)
+   - `.harness/` directory — State and learnings storage
+   - `AGENTS.md` — Agent instructions (template, needs customization)
+   - Layer definitions (intermediate and above)
+   - Dependency constraints (intermediate and above)
+
+3. **Do not blindly accept generated content.** Read the generated `AGENTS.md` and `harness.yaml`. Flag anything that looks wrong or incomplete. The scaffolded output is a starting point, not a finished product.
+
+### Phase 3: CONFIGURE — Customize for the Project
+
+1. **Configure personas.** Run `harness persona generate` to create persona definitions based on the project's stack and team structure. Personas define how agents should behave in this project — coding style, communication preferences, constraint strictness.
+
+2. **Customize AGENTS.md.** The generated template needs project-specific content:
+   - Project description and purpose
+   - Architecture overview (components, layers, data flow)
+   - Key conventions the team follows
+   - Known constraints and forbidden patterns
+   - Links to relevant documentation
+
+3. **For intermediate and above:** Define layer boundaries. Which modules belong to which layers? What are the allowed import directions? Document these in `harness.yaml` and ensure they match the actual codebase structure.
+
+4. **For advanced:** Configure state management (`.harness/state.json` schema), learnings capture (`.harness/learnings.md` conventions), and CI integration hooks.
+
+5. **Configure i18n (all levels).** Ask: "Will this project support multiple languages?" Based on the answer:
+   - **Yes:** Invoke `harness-i18n-workflow` configure phase to set up i18n config in `harness.config.json` (source locale, target locales, framework, strictness). Then invoke `harness-i18n-workflow` scaffold phase to create translation file structure and extraction config. Set `i18n.enabled: true`.
+   - **No:** Set `i18n.enabled: false` in `harness.config.json`. The `harness-i18n-process` skill will still fire gentle prompts for unconfigured projects when features touch user-facing strings.
+   - **Not sure yet:** Skip i18n configuration entirely. Do not set `i18n.enabled`. The project can enable i18n later by running `harness-i18n-workflow` directly.
+
+### Phase 4: VALIDATE — Confirm Everything Works
+
+1. **Run `harness validate`** to verify the full configuration. This checks:
+   - `harness.yaml` schema validity
+   - `AGENTS.md` presence and required sections
+   - Layer definitions (if intermediate+)
+   - Dependency constraints (if intermediate+)
+   - Persona configuration (if configured)
+
+2. **Fix any validation errors before finishing.** Do not leave the project in a half-configured state.
+
+3. **Run `harness check-deps`** (intermediate and above) to verify dependency constraints match the actual codebase. If there are violations, decide with the human: update the constraints or fix the code.
+
+### Build the Initial Knowledge Graph
+
+If the project will use graph-based queries, build the initial knowledge graph now:
+
+```
+harness scan [path]
+```
+
+This creates the `.harness/graph/` directory and populates it with the project's dependency and relationship data. Subsequent graph queries (impact analysis, dependency health, test advisor) depend on this initial scan.
+
+4. **Mention roadmap.** After validation passes, inform the user: "When you are ready to set up a project roadmap, run `/harness:roadmap --create`. This creates a unified `docs/roadmap.md` that tracks features, milestones, and status across your specs and plans." This is informational only — do not create the roadmap automatically.
+
+5. **Commit the initialization.** All generated and configured files in a single commit.
+
+## Harness Integration
+
+- **`harness init --level <level> --framework <framework>`** — Scaffold a new project at the specified adoption level.
+- **`harness init --level <level> --migrate`** — Migrate an existing project to the next adoption level, preserving existing configuration.
+- **`harness persona generate`** — Generate persona definitions based on project stack and team structure.
+- **`harness validate`** — Verify the full project configuration is valid and complete.
+- **`harness check-deps`** — Verify dependency constraints match the actual codebase (intermediate and above).
+- **`harness-i18n-workflow configure` + `harness-i18n-workflow scaffold`** — Invoked during Phase 3 if the project will support multiple languages. Sets up i18n configuration and translation file structure.
+- **Roadmap nudge** — After successful initialization, inform the user about `/harness:roadmap --create` for setting up project-level feature tracking. Informational only; does not create the roadmap.
+
+## Success Criteria
+
+- `harness.yaml` exists and passes schema validation
+- `AGENTS.md` exists with project-specific content (not just the template)
+- `.harness/` directory exists with appropriate state files
+- `harness validate` passes with zero errors
+- `harness check-deps` passes (intermediate and above)
+- Personas are configured if the project uses them
+- The adoption level matches what was agreed upon with the human
+- All generated files are committed in a single atomic commit
+- i18n configuration is set if the human chose to enable it during init
+
+## Examples
+
+### Example: New TypeScript Project (Basic Level)
+
+**ASSESS:**
+
+```
+Human: "I'm starting a new TypeScript API project using Express and Vitest."
+Check for .harness/ — not found. This is a new project.
+Recommend: basic level (new project, start simple).
+Human confirms: "Basic is fine for now."
+```
+
+**SCAFFOLD:**
+
+```bash
+harness init --level basic --framework express
+# Creates: harness.yaml, .harness/, AGENTS.md (template)
+```
+
+**CONFIGURE:**
+
+```
+Edit AGENTS.md:
+  - Add project description: "REST API for widget management"
+  - Add stack: TypeScript, Express, Vitest, PostgreSQL
+  - Add conventions: "Use zod for validation, repository pattern for data access"
+  - Add constraints: "No direct SQL queries outside repository layer"
+  - Ask: "Will this project support multiple languages?"
+  - Human: "Yes, Spanish and French."
+  - Run harness-i18n-workflow configure (source: en, targets: es, fr)
+  - Run harness-i18n-workflow scaffold (creates locales/ directory structure)
+```
+
+**VALIDATE:**
+
+```bash
+harness validate  # Pass — basic level checks satisfied
+git add harness.yaml .harness/ AGENTS.md
+git commit -m "feat: initialize harness project at basic level"
+```
+
+### Example: Migrating Existing Project from Basic to Intermediate
+
+**ASSESS:**
+
+```
+Read harness.yaml — level: basic
+Read AGENTS.md — exists, has project-specific content
+Run: harness validate — passes at basic level
+Recommend: intermediate (add layers and dependency constraints)
+Human confirms: "Yes, we're ready for layers."
+```
+
+**SCAFFOLD:**
+
+```bash
+harness init --level intermediate --migrate
+# Preserves existing harness.yaml and AGENTS.md
+# Adds: layer definitions template, dependency constraints template
+```
+
+**CONFIGURE:**
+
+```
+Define layers in harness.yaml:
+  - presentation: src/routes/, src/middleware/
+  - business: src/services/, src/models/
+  - data: src/repositories/, src/db/
+
+Define constraints:
+  - presentation → business (allowed)
+  - business → data (allowed)
+  - data → presentation (forbidden)
+  - presentation → data (forbidden — must go through business)
+
+Update AGENTS.md with layer documentation.
+```
+
+**VALIDATE:**
+
+```bash
+harness validate      # Pass — intermediate level checks satisfied
+harness check-deps    # Pass — no constraint violations in existing code
+git add -A
+git commit -m "feat: migrate harness project to intermediate level with layers"
+```
+
+### Example: Adoption Level Progression
+
+**Basic (start here):**
+
+- `AGENTS.md` with project context
+- `harness.yaml` with metadata
+- `harness validate` runs in development
+
+**Intermediate (add structure):**
+
+- Layer definitions and boundaries
+- Dependency constraints enforced by `harness check-deps`
+- At least one custom skill for team workflows
+
+**Advanced (full integration):**
+
+- Persona configuration for consistent agent behavior
+- State management across sessions
+- `.harness/learnings.md` capturing institutional knowledge
+- `harness validate` runs in CI pipeline
+- Custom skills for all common team workflows

package/dist/agents/skills/gemini-cli/initialize-harness-project/skill.yaml

@@ -0,0 +1,31 @@
+name: initialize-harness-project
+version: "1.0.0"
+description: Scaffold a new harness-compliant project
+cognitive_mode: constructive-architect
+triggers:
+  - manual
+  - on_project_init
+platforms:
+  - claude-code
+  - gemini-cli
+tools:
+  - Bash
+  - Read
+  - Write
+  - Glob
+cli:
+  command: harness skill run initialize-harness-project
+  args:
+    - name: path
+      description: Project root path
+      required: false
+mcp:
+  tool: run_skill
+  input:
+    skill: initialize-harness-project
+    path: string
+type: flexible
+state:
+  persistent: false
+  files: []
+depends_on: []

package/dist/agents/skills/gemini-cli/validate-context-engineering/SKILL.md

@@ -0,0 +1,150 @@
+# Validate Context Engineering
+
+> Validate AGENTS.md quality and evolve it as the codebase changes. Good context engineering means AI agents always have accurate, current knowledge about the project.
+
+## When to Use
+
+- After adding new files, modules, or packages to the project
+- After renaming, moving, or deleting significant files
+- After changing public APIs, architectural patterns, or conventions
+- When onboarding a new contributor (human or AI) and want to verify context is current
+- When `on_context_check` or `on_pre_commit` triggers fire
+- Periodically (weekly or per-sprint) as a hygiene check
+- NOT when making trivial changes (typo fixes, comment updates, formatting)
+- NOT during active feature development — run this between features or at cycle boundaries
+
+## Process
+
+### Phase 1: Audit — Run Automated Checks
+
+1. **Run `harness validate`** to check overall project health. Review any context-related warnings or errors in the output.
+
+2. **Run `harness check-docs`** to detect documentation gaps, broken links, and stale references. Capture the full output for analysis.
+
+3. **Review AGENTS.md manually.** Automated tools catch structural issues but miss semantic drift. Read each section and ask: "Is this still true?"
+
+### Graph-Enhanced Context (when available)
+
+When a knowledge graph exists at `.harness/graph/`, use graph queries for faster, more accurate auditing:
+
+- `query_graph` — find all undocumented code nodes (file nodes without `documents` edges), replacing manual cross-referencing
+- `search_similar` — detect stale references in AGENTS.md by matching section text against current code entities
+
+When a graph is available, it IS the source of truth for documentation coverage. Drift = stale or missing edges between code and doc nodes. Fall back to file-based commands if no graph is available.
+
+### Pipeline Context (when orchestrated)
+
+When invoked by `harness-docs-pipeline`, check for a `pipeline` field in `.harness/handoff.json`:
+
+- If `pipeline` field exists: read `DocPipelineContext` from it
+  - Use `pipeline.exclusions` to skip findings that were already addressed in the FIX phase
+  - Write `GapFinding[]` results back to `pipeline.gapFindings` in handoff.json
+  - This enables dedup across FIX and AUDIT phases
+- If `pipeline` field does not exist: behave exactly as today (standalone mode)
+
+No changes to the skill's interface or output format — the pipeline field is purely additive.
+
+### Phase 2: Detect Gaps
+
+Categorize findings into four types:
+
+1. **Undocumented files.** New source files, modules, or packages that are not mentioned in AGENTS.md or any knowledge map section. These are the highest priority — an AI agent encountering these files has no context.
+
+2. **Broken links.** References to files, functions, or URLs that no longer exist. These actively mislead agents.
+
+3. **Stale sections.** Content that was accurate when written but no longer reflects reality. Examples: renamed functions still referenced by old name, removed features still described, changed conventions not updated.
+
+4. **Missing context.** Sections that exist but lack critical information. A module is listed but its purpose, constraints, or relationships are not explained. An AI agent can find the file but does not understand why it exists or how to use it correctly.
+
+### Phase 3: Suggest Updates
+
+For each gap, generate a specific suggestion:
+
+- **Undocumented files:** Draft a new section or entry with the file path, purpose, key exports, and relationship to existing modules. Use the existing AGENTS.md style and structure.
+- **Broken links:** Identify the correct target (renamed file, moved function) or recommend removal if the target was deleted.
+- **Stale sections:** Draft replacement text that reflects current reality. Show the diff between old and new.
+- **Missing context:** Draft additional content that fills the gap. Focus on what an AI agent needs to know: purpose, constraints, relationships, and gotchas.
+
+### Phase 4: Apply with Approval
+
+1. **Present all suggestions as a grouped list.** Organize by section of AGENTS.md for easy review.
+
+2. **Apply approved changes.** Update AGENTS.md with the approved suggestions. Preserve existing formatting and style.
+
+3. **Re-run `harness check-docs`** to verify all fixes are clean. No new issues should be introduced.
+
+4. **Commit the update.** Use a descriptive commit message that summarizes what was updated and why.
+
+## What Makes Good AGENTS.md Content
+
+Good context engineering treats AGENTS.md as a **dynamic knowledge base**, not a static document.
+
+- **Accuracy over completeness.** A small, accurate AGENTS.md is better than a comprehensive but stale one. Every statement must be verifiable against the current codebase.
+- **Purpose-first descriptions.** Do not just list files. Explain WHY each module exists, what problem it solves, and what constraints apply to it.
+- **Relationship mapping.** Show how modules connect. Which modules depend on which? What are the boundaries? An agent reading one section should understand how it fits into the whole.
+- **Gotchas and constraints.** Document the non-obvious. What will break if someone does X? What patterns must be followed? What is forbidden and why?
+- **Change-friendly structure.** Organize so that adding a new module means adding one section, not updating ten places. Use consistent formatting so automated tools can parse it.
+- **Actionable guidance.** Every section should help an agent make correct decisions. "This module handles authentication" is less useful than "This module handles authentication. All auth changes must go through the AuthService class. Direct database access for auth data is forbidden — use the repository layer."
+
+## Harness Integration
+
+- **`harness validate`** — Full project health check. Reports context gaps as part of overall validation.
+- **`harness check-docs`** — Focused documentation audit. Detects broken links, missing references, stale sections, and undocumented files.
+- **`harness fix-drift`** — Auto-fix simple drift issues (broken links, renamed references). Use after manual review confirms the fixes are correct.
+
+## Success Criteria
+
+- `harness check-docs` passes with zero errors and zero warnings
+- Every source file that contains public API or architectural significance is referenced in AGENTS.md
+- All file paths and function names in AGENTS.md match the current codebase
+- All links (internal and external) resolve correctly
+- AGENTS.md sections accurately describe current module purposes, constraints, and relationships
+- A new AI agent reading AGENTS.md can navigate the codebase and make correct decisions without additional guidance
+
+## Examples
+
+### Example: New module added but not documented
+
+**Audit output from `harness check-docs`:**
+
+```
+WARNING: Undocumented file detected: src/services/notification-service.ts
+  - File contains 3 public exports: NotificationService, NotificationType, sendNotification
+  - File is imported by 4 other modules
+  - No AGENTS.md section references this file
+```
+
+**Suggested update:**
+
+```markdown
+### Notification Service (`src/services/notification-service.ts`)
+
+Handles all outbound notifications (email, Slack, webhook). All notification delivery
+must go through `NotificationService` — direct use of transport libraries (nodemailer,
+Slack SDK) outside this module is forbidden.
+
+- `NotificationType` — enum of supported notification channels
+- `sendNotification()` — primary entry point; routes to the correct transport
+- Requires `NOTIFICATION_CONFIG` environment variables to be set
+- Respects rate limits defined in `harness.config.json` under `notifications`
+```
+
+**Apply:** Add the section under the Services heading in AGENTS.md. Re-run `harness check-docs` to confirm the warning is resolved.
+
+### Example: Renamed function still referenced by old name
+
+**Audit output:**
+
+```
+ERROR: Broken reference in AGENTS.md line 47: `calculateShipping()`
+  - Function was renamed to `computeShippingCost()` in commit abc123
+  - Located in src/services/shipping.ts
+```
+
+**Fix:** Replace `calculateShipping()` with `computeShippingCost()` in AGENTS.md. Verify no other references to the old name exist.
+
+## Escalation
+
+- **When AGENTS.md is severely outdated (>20 issues):** Do not attempt to fix everything at once. Prioritize: broken links first, then undocumented public APIs, then stale descriptions. Batch the work across multiple commits.
+- **When you are unsure whether a section is stale:** Check git blame for the section and compare against recent changes to the referenced files. If the section has not been updated since the referenced files changed, it is likely stale.
+- **When the project has no AGENTS.md:** Escalate to the human. Creating an AGENTS.md from scratch is a significant decision about project structure and should be done intentionally, not automatically.

package/dist/agents/skills/gemini-cli/validate-context-engineering/skill.yaml

@@ -0,0 +1,31 @@
+name: validate-context-engineering
+version: "1.0.0"
+description: Validate repository context engineering practices (AGENTS.md, doc coverage, knowledge map)
+cognitive_mode: meticulous-verifier
+triggers:
+  - manual
+  - on_pr
+  - on_commit
+platforms:
+  - claude-code
+  - gemini-cli
+tools:
+  - Bash
+  - Read
+  - Glob
+cli:
+  command: harness skill run validate-context-engineering
+  args:
+    - name: path
+      description: Project root path
+      required: false
+mcp:
+  tool: run_skill
+  input:
+    skill: validate-context-engineering
+    path: string
+type: flexible
+state:
+  persistent: false
+  files: []
+depends_on: []

package/dist/bin/harness.js

@@ -3,8 +3,8 @@ import {
   createProgram,
   findConfigFile,
   loadConfig
-} from "../chunk-LNI4T7R6.js";
-import "../chunk-3JWCBVUZ.js";
+} from "../chunk-KJANDVVC.js";
+import "../chunk-RT2LYQHF.js";
 import {
   VERSION,
   getUpdateNotification,
@@ -12,7 +12,7 @@ import {
   readCheckState,
   shouldRunCheck,
   spawnBackgroundCheck
-} from "../chunk-SJECMKSS.js";
+} from "../chunk-E2RTDBMG.js";
 import {
   handleError
 } from "../chunk-ACMDUQJG.js";

package/dist/{chunk-SJECMKSS.js → chunk-E2RTDBMG.js}

@@ -805,13 +805,17 @@ var PHASE_PRIORITIES = {
       priority: 2
     },
     { category: "tests", patterns: ["tests/**/*.test.ts", "**/*.spec.ts"], priority: 3 },
-    { category: "specs", patterns: ["docs/specs/**/*.md"], priority: 4 },
+    { category: "specs", patterns: ["docs/changes/*/proposal.md"], priority: 4 },
     { category: "config", patterns: ["package.json", "tsconfig.json"], priority: 5 }
   ],
   review: [
     { category: "diff", patterns: [], priority: 1 },
     // Diff is provided, not globbed
-    { category: "specs", patterns: ["docs/specs/**/*.md", "docs/plans/**/*.md"], priority: 2 },
+    {
+      category: "specs",
+      patterns: ["docs/changes/*/proposal.md", "docs/plans/**/*.md"],
+      priority: 2
+    },
     { category: "learnings", patterns: [".harness/review-learnings.md"], priority: 3 },
     { category: "types", patterns: ["src/**/types.ts", "src/**/interfaces.ts"], priority: 4 },
     { category: "tests", patterns: ["tests/**/*.test.ts"], priority: 5 }
@@ -824,7 +828,11 @@ var PHASE_PRIORITIES = {
     { category: "types", patterns: ["src/**/types.ts"], priority: 5 }
   ],
   plan: [
-    { category: "specs", patterns: ["docs/specs/**/*.md", "docs/plans/**/*.md"], priority: 1 },
+    {
+      category: "specs",
+      patterns: ["docs/changes/*/proposal.md", "docs/plans/**/*.md"],
+      priority: 1
+    },
     { category: "architecture", patterns: ["AGENTS.md", "docs/standard/**/*.md"], priority: 2 },
     { category: "handoffs", patterns: [".harness/handoff.md"], priority: 3 },
     { category: "types", patterns: ["src/**/types.ts", "src/**/interfaces.ts"], priority: 4 },
@@ -872,7 +880,7 @@ function resolveImportPath(importSource, fromFile, _rootDir) {
   if (!resolved.endsWith(".ts") && !resolved.endsWith(".tsx")) {
     resolved = resolved + ".ts";
   }
-  return resolved;
+  return resolved.replace(/\\/g, "/");
 }
 function getImportType(imp) {
   if (imp.kind === "type") return "type-only";
@@ -885,9 +893,10 @@ async function buildDependencyGraph(files, parser, graphDependencyData) {
       edges: graphDependencyData.edges
     });
   }
-  const nodes = [...files];
+  const nodes = files.map((f) => f.replace(/\\/g, "/"));
   const edges = [];
   for (const file of files) {
+    const normalizedFile = file.replace(/\\/g, "/");
     const parseResult = await parser.parseFile(file);
     if (!parseResult.ok) {
       continue;
@@ -900,7 +909,7 @@ async function buildDependencyGraph(files, parser, graphDependencyData) {
       const resolvedPath = resolveImportPath(imp.source, file, "");
       if (resolvedPath) {
         edges.push({
-          from: file,
+          from: normalizedFile,
           to: resolvedPath,
           importType: getImportType(imp),
           line: imp.location.line
@@ -3847,7 +3856,7 @@ var CriticalPathResolver = class {
       return;
     }
     const lines = content.split("\n");
-    const relativePath = path.relative(this.projectRoot, filePath);
+    const relativePath = path.relative(this.projectRoot, filePath).replace(/\\/g, "/");
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
       if (!line.includes("@perf-critical")) continue;
@@ -7322,8 +7331,10 @@ function extractCrossFileRefs(finding) {
 }
 function normalizePath(filePath, projectRoot) {
   let normalized = filePath;
+  normalized = normalized.replace(/\\/g, "/");
+  const normalizedRoot = projectRoot.replace(/\\/g, "/");
   if (path8.isAbsolute(normalized)) {
-    const root = projectRoot.endsWith(path8.sep) ? projectRoot : projectRoot + path8.sep;
+    const root = normalizedRoot.endsWith("/") ? normalizedRoot : normalizedRoot + "/";
     if (normalized.startsWith(root)) {
       normalized = normalized.slice(root.length);
     }
@@ -7331,7 +7342,7 @@ function normalizePath(filePath, projectRoot) {
   if (normalized.startsWith("./")) {
     normalized = normalized.slice(2);
   }
-  return path8.normalize(normalized);
+  return normalized;
 }
 function followImportChain(fromFile, fileContents, maxDepth = 2) {
   const visited = /* @__PURE__ */ new Set();
@@ -7348,11 +7359,11 @@ function followImportChain(fromFile, fileContents, maxDepth = 2) {
       const importPath = match[1];
       if (!importPath.startsWith(".")) continue;
       const dir = path8.dirname(current.file);
-      let resolved = path8.join(dir, importPath);
+      let resolved = path8.join(dir, importPath).replace(/\\/g, "/");
       if (!resolved.match(/\.(ts|tsx|js|jsx)$/)) {
         resolved += ".ts";
       }
-      resolved = path8.normalize(resolved);
+      resolved = path8.normalize(resolved).replace(/\\/g, "/");
       if (!visited.has(resolved) && current.depth + 1 <= maxDepth) {
         queue.push({ file: resolved, depth: current.depth + 1 });
       }
@@ -7369,7 +7380,7 @@ async function validateFindings(options) {
     if (exclusionSet.isExcluded(normalizedFile, finding.lineRange) || exclusionSet.isExcluded(finding.file, finding.lineRange)) {
       continue;
     }
-    const absoluteFile = path8.isAbsolute(finding.file) ? finding.file : path8.join(projectRoot, finding.file);
+    const absoluteFile = path8.isAbsolute(finding.file) ? finding.file : path8.join(projectRoot, finding.file).replace(/\\/g, "/");
     if (exclusionSet.isExcluded(absoluteFile, finding.lineRange)) {
       continue;
     }
@@ -8106,7 +8117,8 @@ var EmitInteractionInputSchema = z5.object({
   transition: TransitionSchema.optional()
 });
 function getStatePath() {
-  return path10.join(os.homedir(), ".harness", "update-check.json");
+  const home = process.env["HOME"] || os.homedir();
+  return path10.join(home, ".harness", "update-check.json");
 }
 function isUpdateCheckEnabled(configInterval) {
   if (process.env["HARNESS_NO_UPDATE_CHECK"] === "1") return false;