@mikenguyen69/harness 0.1.0-beta.1 → 0.1.0-beta.2

package/dist/internal/system/assets.js

@@ -29,6 +29,29 @@ export function packageProfilesDir(fromUrl = import.meta.url) {
 export function packageTemplatesDir(fromUrl = import.meta.url) {
     return resolvePackageAsset(fromUrl, "templates", "ci-templates");
 }
+/**
+ * Intake kit templates for `harness init`.
+ * Prefer staged `templates/target-kit`; fall back to the portfolio docs path
+ * when developing against the system-harness workspace checkout.
+ */
+export function packageTargetKitDir(fromUrl = import.meta.url) {
+    const here = dirname(fileURLToPath(fromUrl));
+    let dir = here;
+    while (true) {
+        const staged = join(dir, "templates", "target-kit");
+        if (existsSync(join(staged, "component.toml")))
+            return resolve(staged);
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // Workspace: repos/system-harness/{src,dist}/… → orchestration docs kit
+    const workspaceKit = resolve(here, "..", "..", "..", "orchestration-harness", "docs", "target-kit");
+    if (existsSync(join(workspaceKit, "component.toml")))
+        return workspaceKit;
+    throw new Error(`target-kit templates not found (looked for templates/target-kit from ${fileURLToPath(fromUrl)})`);
+}
 export function targetPath(repoRoot, ...segments) {
     return resolve(repoRoot, ...segments);
 }

package/dist/internal/system/init/index.js

@@ -1,20 +1,28 @@
 /**
- * init — scaffold hooks (`harness hook pre-tool-use`).
+ * init — scaffold hooks + target intake kit (TypeScript profile by default).
  *
  * Named owner of init-composes-hook-install: system-harness `init` invokes the
  * agent-harness hook-install path (`adapter/install`) directly as a subprocess
  * composition. system-harness does not import `@harness/agent`. The published
  * facade only routes `harness init` here and adds no hook-install logic.
+ *
+ * Default init also copies package-owned target-kit templates and the chosen
+ * language profile into the target repo (skip existing files). `--hooks-only`
+ * restores the previous hooks-only behaviour.
  */
 import { spawnSync } from "node:child_process";
-import { existsSync, mkdirSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { packageProfilesDir, packageTemplatesDir, targetOwnedPaths, targetPath, } from "../assets.js";
+import { packageProfilesDir, packageTargetKitDir, packageTemplatesDir, targetOwnedPaths, targetPath, } from "../assets.js";
 /** Public facade hook command — never an internal binary path. */
 export const HOOK_COMMAND = "harness hook pre-tool-use";
 /** Documented composition: system init → agent-harness adapter/install. */
 export const HOOK_INSTALL_OWNER = "system-harness init composes agent-harness adapter/install";
+/** Default language profile scaffolded into the target. */
+export const DEFAULT_INIT_PROFILE = "typescript";
+/** Kit files that stay package-local documentation, not target config. */
+const KIT_SKIP = new Set(["README.md"]);
 function resolveAgentHookInstall() {
     const here = dirname(fileURLToPath(import.meta.url));
     const fromEnv = process.env.AGENT_HARNESS_BIN;
@@ -48,13 +56,97 @@ export function writeInitHooks(repoRoot, _command = HOOK_COMMAND) {
     const written = (result.stdout ?? "").trim();
     return written || targetPath(repoRoot, ".claude", "settings.json");
 }
-export function runInit(repoRoot) {
+function walkFiles(root, prefix = "") {
+    const out = [];
+    if (!existsSync(root))
+        return out;
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+        const abs = join(root, entry.name);
+        if (entry.isDirectory())
+            out.push(...walkFiles(abs, rel));
+        else if (entry.isFile())
+            out.push(rel.replaceAll("\\", "/"));
+    }
+    return out;
+}
+/**
+ * Copy intake kit + language profile into the target. Never overwrites.
+ */
+export function scaffoldTargetKit(repoRoot, options = {}) {
+    const root = resolve(repoRoot);
+    const profile = options.profile ?? DEFAULT_INIT_PROFILE;
+    const fromUrl = options.fromUrl ?? import.meta.url;
+    const kitDir = packageTargetKitDir(fromUrl);
+    const packageProfiles = packageProfilesDir(fromUrl);
+    const profileSrc = join(packageProfiles, profile, "bindings.toml");
+    if (!existsSync(profileSrc)) {
+        throw new Error(`profile "${profile}" not found under ${packageProfiles} (expected ${profile}/bindings.toml)`);
+    }
+    const written = [];
+    const skipped = [];
+    const copyOne = (src, destRel) => {
+        const dest = join(root, destRel);
+        if (existsSync(dest)) {
+            skipped.push(destRel.replaceAll("\\", "/"));
+            return;
+        }
+        mkdirSync(dirname(dest), { recursive: true });
+        copyFileSync(src, dest);
+        written.push(destRel.replaceAll("\\", "/"));
+    };
+    for (const rel of walkFiles(kitDir)) {
+        const base = rel.split("/").pop() ?? rel;
+        if (KIT_SKIP.has(base))
+            continue;
+        // Old kit layout may still ship profiles/target — skip; we install the
+        // language profile from package profiles/ instead.
+        if (rel.startsWith("profiles/"))
+            continue;
+        copyOne(join(kitDir, rel), rel);
+    }
+    copyOne(profileSrc, join("profiles", profile, "bindings.toml"));
+    ensureGitignoreHarness(root, written, skipped);
+    return {
+        written,
+        skipped,
+        profile,
+        kitDir,
+        profilesDir: packageProfiles,
+    };
+}
+function ensureGitignoreHarness(repoRoot, written, skipped) {
+    const rel = ".gitignore";
+    const dest = join(repoRoot, rel);
+    const marker = ".harness/";
+    if (!existsSync(dest)) {
+        writeFileSync(dest, `${marker}\n`, "utf8");
+        written.push(rel);
+        return;
+    }
+    const body = readFileSync(dest, "utf8");
+    if (body.split(/\r?\n/).some((line) => line.trim() === marker || line.trim() === ".harness")) {
+        skipped.push(rel);
+        return;
+    }
+    const next = body.endsWith("\n") || body.length === 0 ? `${body}${marker}\n` : `${body}\n${marker}\n`;
+    writeFileSync(dest, next, "utf8");
+    written.push(`${rel} (+${marker})`);
+}
+export function runInit(repoRoot, options = {}) {
     const root = resolve(repoRoot);
+    const hooksPath = writeInitHooks(root);
+    const profilesDir = packageProfilesDir();
+    const templatesDir = packageTemplatesDir();
+    const scaffold = options.hooksOnly
+        ? null
+        : scaffoldTargetKit(root, { profile: options.profile ?? DEFAULT_INIT_PROFILE });
     return {
         repoRoot: root,
-        hooksPath: writeInitHooks(root),
-        profilesDir: packageProfilesDir(),
-        templatesDir: packageTemplatesDir(),
+        hooksPath,
+        profilesDir,
+        templatesDir,
+        scaffold,
     };
 }
 function flag(args, name) {
@@ -63,16 +155,41 @@ function flag(args, name) {
 }
 export function initCommand(args, cwd = process.cwd()) {
     if (args.includes("--help") || args.includes("-h")) {
-        process.stdout.write("harness init [--cwd <dir>]  scaffold hooks (harness hook pre-tool-use)\n");
+        process.stdout.write([
+            "harness init [--cwd <dir>] [--profile <name>] [--hooks-only]",
+            "",
+            "Scaffold the target intake kit (TypeScript profile by default), ensure",
+            ".harness/ is gitignored, and install the agent PreToolUse hook",
+            `(${HOOK_COMMAND}). Existing files are left untouched.`,
+            "",
+            "  --hooks-only   only install hooks (skip kit / profile copy)",
+            "  --profile      language profile to copy (default: typescript)",
+            "",
+        ].join("\n"));
         return 0;
     }
     const repo = resolve(flag(args, "cwd") ?? cwd);
     mkdirSync(targetOwnedPaths(repo).harnessDir, { recursive: true });
     try {
-        const result = runInit(repo);
+        const result = runInit(repo, {
+            hooksOnly: args.includes("--hooks-only"),
+            ...(flag(args, "profile") ? { profile: flag(args, "profile") } : {}),
+        });
         process.stdout.write(`✓ hooks  ${result.hooksPath}\n`);
-        process.stdout.write(`  (profiles from ${result.profilesDir})\n`);
-        process.stdout.write(`  (templates from ${result.templatesDir})\n`);
+        if (result.scaffold) {
+            const { written, skipped, profile } = result.scaffold;
+            process.stdout.write(`✓ kit    profile=${profile}\n`);
+            for (const rel of written)
+                process.stdout.write(`  + ${rel}\n`);
+            for (const rel of skipped)
+                process.stdout.write(`  = ${rel} (exists)\n`);
+            process.stdout.write("  Next: replace every REPLACE marker, then harness doctor / spec check.\n");
+        }
+        else {
+            process.stdout.write("  (hooks-only — kit not scaffolded)\n");
+        }
+        process.stdout.write(`  (package profiles ${result.profilesDir})\n`);
+        process.stdout.write(`  (package templates ${result.templatesDir})\n`);
         return 0;
     }
     catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikenguyen69/harness",
-  "version": "0.1.0-beta.1",
+  "version": "0.1.0-beta.2",
   "description": "One installed `harness` command over the portfolio — routing facade, not a fourth control loop.",
   "type": "module",
   "engines": {

package/templates/target-kit/README.md

@@ -10,15 +10,16 @@ materializing a unit.
 [docs/onboarding.md](../../../../docs/onboarding.md). Do not wire compiled
 portfolio entrypoints for target work.
 
-Expected target layout:
+Expected target layout (written by `harness init`):
 
 ```text
 component.toml
 system.toml
 routes.toml
 orchestration.json
-profiles/target/bindings.toml
+profiles/typescript/bindings.toml
 specs/first-unit.yaml
+.gitignore          # ensures .harness/ is ignored
 ```
 
 Before dispatch, record:
@@ -39,18 +40,20 @@ Before dispatch, record:
 
 Then:
 
-1. Copy and customize all templates.
-2. Run `rg -n "REPLACE" component.toml system.toml routes.toml orchestration.json profiles specs`; zero matches are required.
-3. From the target root, scaffold hooks (no separate hook-install step):
+1. From the target root, scaffold the kit + hooks (no manual copy of this directory):
 
 ```sh
 harness init
+# or: harness init --hooks-only   # hooks only, if the kit is already present
 ```
 
-   Hook installation is one step of `harness init`. Owner: system-harness
+   `harness init` copies these templates and `profiles/typescript/` from the
+   installed package, ensures `.harness/` is gitignored, and installs the
+   PreToolUse hook. Existing files are left untouched. Owner: system-harness
    `init` composing the agent-harness hook-install path; generated commands call
    `harness hook pre-tool-use`.
-4. Read-only preflight, then materialize once:
+2. Customize every scaffolded file. Run `rg -n "REPLACE" component.toml system.toml routes.toml orchestration.json profiles specs`; zero matches are required.
+3. Read-only preflight, then materialize once:
 
 ```sh
 harness spec check --specs ./specs --system ./system.toml
@@ -58,8 +61,8 @@ harness spec materialize --specs ./specs --system ./system.toml --ledger ./.harn
 harness doctor --repo . --routes ./routes.toml --spool ./.harness/spool --json
 ```
 
-5. Review doctor’s resolved runner/model, commands, budgets, base branch, and dirty-tree decision.
-6. Obtain separate authorization for the target dispatch and its merge policy.
+4. Review doctor’s resolved runner/model, commands, budgets, base branch, and dirty-tree decision.
+5. Obtain separate authorization for the target dispatch and its merge policy.
    Installing `@mikenguyen69/harness` authorizes neither a dry run nor a real target
    run. `doctor` / `spec check` do not dispatch agents.
 

package/templates/target-kit/component.toml

@@ -1,7 +1,8 @@
 # REPLACE every command/decline rationale with the target's reviewed policy.
+# Defaults come from profiles/typescript/bindings.toml; entries here override.
 [harness]
 policy_version = "0.0.1"
-profile = "target"
+profile = "typescript"
 mode = "standard"
 
 [gates]

package/templates/target-kit/routes.toml

@@ -1,5 +1,5 @@
 [[route]]
-profile = "target"
+profile = "typescript"
 runner = "claude"
 model = "REPLACE-approved-model"
 mode = "standard"

package/templates/target-kit/system.toml

@@ -4,4 +4,4 @@ id = "REPLACE-target-system-id"
 [[component]]
 id = "app"
 root = "."
-profile = "target"
+profile = "typescript"

package/templates/target-kit/profiles/target/bindings.toml

@@ -1,6 +0,0 @@
-[harness]
-profile_version = "0.0.1"
-
-# The component contract owns the initial bindings. Move stable, shared target
-# bindings here only after the first dry run proves them.
-[gates]