@mannyc1/ts-release 0.0.6 → 0.2.2

package/apps/release-ts/src/cli/command.ts

@@ -0,0 +1,164 @@
+import * as Effect from "effect/Effect"
+import * as Argument from "effect/unstable/cli/Argument"
+import * as Command from "effect/unstable/cli/Command"
+import * as Flag from "effect/unstable/cli/Flag"
+import {
+  commandNames,
+  decodeLocalPreparedReference,
+  defaultStoreDirectory,
+  resolveStoreDirectory,
+  runCorrect,
+  runInit,
+  runInspect,
+  runObserve,
+  runPrepare,
+  runPublish,
+  runRelease,
+  type CliApi,
+  type CliApiFactory,
+  type CliIo
+} from "./commands.js"
+
+export {
+  commandNames,
+  type CliApi,
+  type CliApiFactory,
+  type CliIo
+} from "./commands.js"
+
+const text = (name: string, fallback?: string) => fallback === undefined
+  ? Flag.string(name)
+  : Flag.string(name).pipe(Flag.withDefault(fallback))
+
+const optionalText = (name: string) => Flag.string(name).pipe(Flag.optional)
+const optionalArgument = (name: string) => Argument.string(name).pipe(Argument.optional)
+
+const at = <A>(value: import("effect/Option").Option<A>): A | undefined =>
+  value._tag === "Some" ? value.value : undefined
+
+const promise = <A>(evaluate: () => Promise<A>) => Effect.tryPromise({
+  try: evaluate,
+  catch: (cause) => cause
+})
+
+export const makeCli = (
+  makeApi: CliApiFactory,
+  cwd: string,
+  io: CliIo
+) => {
+  const application = Command.make("ts-release").pipe(
+    Command.withDescription("Deterministic preparation, publication, and correction."),
+    Command.withSharedFlags({
+      store: text("store", defaultStoreDirectory(cwd))
+    })
+  )
+
+  const withApi = (operation: (api: CliApi) => Promise<void>) => Effect.gen(function*() {
+    const { store } = yield* application
+    const api = yield* Effect.try({
+      try: () => makeApi(resolveStoreDirectory(cwd, store)),
+      catch: (cause) => cause
+    })
+    yield* Effect.acquireUseRelease(
+      Effect.succeed(api),
+      () => promise(() => operation(api)),
+      () => Effect.promise(() => api.dispose())
+    )
+  })
+
+  const decode = (value: string) => promise(() => decodeLocalPreparedReference(value))
+
+  const initCommand = Command.make("init", {
+    config: text("config", "release.config.json"),
+    root: text("root", "."),
+    dryRun: Flag.boolean("dry-run").pipe(Flag.withDefault(false)),
+    force: Flag.boolean("force").pipe(Flag.withDefault(false)),
+    preset: Flag.choice("preset", ["bun-npm-github"] as const).pipe(Flag.optional),
+    prepareOnly: Flag.boolean("prepare-only").pipe(Flag.withDefault(false))
+  }, (options) => {
+    const preset = at(options.preset) as "bun-npm-github" | undefined
+    const { preset: _preset, ...rest } = options
+    return withApi((api) => runInit(
+      api,
+      { ...rest, ...(preset === undefined ? {} : { preset }) },
+      cwd,
+      io
+    ))
+  }).pipe(Command.withDescription(
+    "Create an explicit automatic-release preset or a preparation-only configuration."
+  ))
+
+  const inspectCommand = Command.make("inspect", {
+    prepared: optionalArgument("prepared"),
+    config: optionalText("config"),
+    root: text("root", ".")
+  }, (options) => Effect.gen(function*() {
+    const preparedText = at(options.prepared)
+    const prepared = preparedText === undefined
+      ? undefined
+      : yield* decode(preparedText)
+    const config = at(options.config)
+    yield* withApi((api) => runInspect(api, {
+      root: options.root,
+      ...(config === undefined ? {} : { config }),
+      ...(prepared === undefined ? {} : { prepared })
+    }, cwd, io))
+  })).pipe(Command.withDescription("Inspect authored configuration or a prepared release."))
+
+  const prepareCommand = Command.make("prepare", {
+    config: text("config", "release.config.json"),
+    root: text("root", ".")
+  }, (options) => withApi((api) => runPrepare(api, options, cwd, io))).pipe(
+    Command.withDescription("Build and durably store an exact prepared release bundle.")
+  )
+
+  const observeCommand = Command.make("observe", {
+    prepared: Argument.string("prepared").pipe(
+      Argument.withDescription("Canonical local prepared reference.")
+    )
+  }, (options) => Effect.gen(function*() {
+    const prepared = yield* decode(options.prepared)
+    yield* withApi((api) => runObserve(api, { prepared }, cwd, io))
+  })).pipe(Command.withDescription("Observe a prepared release without mutation."))
+
+  const publishCommand = Command.make("publish", {
+    prepared: Argument.string("prepared").pipe(
+      Argument.withDescription("Canonical local prepared reference.")
+    )
+  }, (options) => Effect.gen(function*() {
+    const prepared = yield* decode(options.prepared)
+    yield* withApi((api) => runPublish(api, { prepared }, cwd, io))
+  })).pipe(Command.withDescription("Observe and publish one prepared release."))
+
+  const releaseCommand = Command.make("release", {
+    config: text("config", "release.config.json"),
+    root: text("root", ".")
+  }, (options) => withApi((api) => runRelease(api, options, cwd, io))).pipe(
+    Command.withDescription("Prepare, durably store, and publish automatically.")
+  )
+
+  const correctCommand = Command.make("correct", {
+    prepared: Argument.string("prepared").pipe(
+      Argument.withDescription("Canonical local prepared reference.")
+    ),
+    correction: Argument.string("correction").pipe(
+      Argument.withDescription("Authored correction file.")
+    )
+  }, (options) => Effect.gen(function*() {
+    const prepared = yield* decode(options.prepared)
+    yield* withApi((api) => runCorrect(api, {
+      prepared,
+      correction: options.correction
+    }, cwd, io))
+  })).pipe(Command.withDescription("Apply one provider-specific forward correction."))
+
+  return application.pipe(Command.withSubcommands([
+    initCommand,
+    inspectCommand,
+    prepareCommand,
+    observeCommand,
+    publishCommand,
+    releaseCommand,
+    correctCommand
+  ]))
+}

package/apps/release-ts/src/cli/commands.ts

@@ -0,0 +1,351 @@
+import {
+  ReleaseAbortedError,
+  ReleaseIncompleteError,
+  ReleasePreparationError,
+  decodeCompletePreparedReleaseRef,
+  encodeCompletePreparedReleaseRef,
+  type CompletePreparedReleaseRef,
+  type CorrectInput,
+  type InspectOutput,
+  type LocalCompletePreparedReleaseRef,
+  type ReleaseApi
+} from "@mannyc1/ts-release"
+import * as Effect from "effect/Effect"
+import * as Schema from "effect/Schema"
+import { realpathSync } from "node:fs"
+import { dirname, isAbsolute, resolve } from "node:path"
+
+export const commandNames = [
+  "init",
+  "inspect",
+  "prepare",
+  "observe",
+  "publish",
+  "release",
+  "correct"
+] as const
+
+export interface CliIo {
+  readonly read: (path: string) => string
+  readonly write: (path: string, value: string) => void
+  readonly log: (value: string) => void
+}
+
+export type CliApi = Pick<
+  ReleaseApi,
+  "inspect" | "prepare" | "observe" | "publish" | "release" | "correct"
+>
+
+export type DisposableCliApi = CliApi & Pick<ReleaseApi, "dispose">
+export type CliApiFactory = (storeDirectory: string) => DisposableCliApi
+
+export class HostedPreparedReferenceUnsupported
+  extends Schema.TaggedErrorClass<HostedPreparedReferenceUnsupported>()(
+    "HostedPreparedReferenceUnsupported",
+    {
+      prepared: Schema.String,
+      reason: Schema.String
+    }
+  ) {}
+
+const json = (io: CliIo, path: string): unknown =>
+  JSON.parse(io.read(realpathSync(path))) as unknown
+
+const pathFrom = (cwd: string, value: string): string =>
+  isAbsolute(value) ? value : resolve(cwd, value)
+
+const workspaceFor = (cwd: string, config: string, root: string | undefined): string =>
+  realpathSync(root === undefined
+    ? isAbsolute(config)
+      ? dirname(pathFrom(cwd, config))
+      : cwd
+    : pathFrom(cwd, root))
+
+export const defaultStoreDirectory = (cwd: string): string =>
+  resolve(cwd, ".release", "ts-release", "prepared")
+
+export const resolveStoreDirectory = (cwd: string, value: string): string =>
+  pathFrom(cwd, value)
+
+const requireLocalPreparedReference = (
+  prepared: CompletePreparedReleaseRef
+): LocalCompletePreparedReleaseRef => {
+  if (prepared.scheme === "local") return prepared
+  const encoded = encodeCompletePreparedReleaseRef(prepared)
+  throw new HostedPreparedReferenceUnsupported({
+    prepared: encoded,
+    reason: "This reference is loadable by a workflow job with actions:read; " +
+      "re-run the failed run's publish job or dispatch the recovery workflow " +
+      `with prepared-ref=${encoded}.`
+  })
+}
+
+export const decodeLocalPreparedReference = async (
+  value: string
+): Promise<LocalCompletePreparedReleaseRef> => requireLocalPreparedReference(
+  await Effect.runPromise(decodeCompletePreparedReleaseRef(value))
+)
+
+export type InitPreset = "bun-npm-github"
+
+export interface InitOptions {
+  readonly config: string
+  readonly root: string
+  readonly dryRun: boolean
+  readonly force: boolean
+  readonly preset?: InitPreset
+  readonly prepareOnly: boolean
+}
+
+export interface InspectOptions {
+  readonly config?: string
+  readonly prepared?: LocalCompletePreparedReleaseRef
+  readonly root: string
+}
+
+export interface PrepareOptions {
+  readonly config: string
+  readonly root: string
+}
+
+export interface ObserveOptions {
+  readonly prepared: LocalCompletePreparedReleaseRef
+}
+
+export interface PublishOptions {
+  readonly prepared: LocalCompletePreparedReleaseRef
+}
+
+export interface ReleaseOptions {
+  readonly config: string
+  readonly root: string
+}
+
+export interface CorrectOptions {
+  readonly prepared: LocalCompletePreparedReleaseRef
+  readonly correction: string
+}
+
+const repositoryFromInspection = (inspection: InspectOutput): string => {
+  if (!("package" in inspection) || inspection.source.repository === undefined) {
+    throw new Error(
+      "The bun-npm-github preset requires a GitHub owner/repository coordinate " +
+      "from the origin remote or package.json repository field."
+    )
+  }
+  return inspection.source.repository
+}
+
+const printJson = (io: CliIo, value: unknown): void =>
+  io.log(JSON.stringify(value, (_key, item) =>
+    typeof item === "object" && item !== null && !Array.isArray(item) &&
+      Object.getPrototypeOf(item) !== Object.prototype && Object.getPrototypeOf(item) !== null &&
+      "toString" in item && item.toString !== Object.prototype.toString &&
+      Object.keys(item).length === 1
+      ? String(item)
+      : item))
+
+const scopeWarning =
+  "publish re-observes every subject and mutates only what a provider decision authorizes; " +
+  "conflicts and unobservable outcomes still require operator action."
+
+const unknownStateWarning =
+  "publish re-observes every subject; per-subject state is unknown until reobserved, " +
+  "and mutation occurs only after a provider decision."
+
+const resumeLine = (prepared: LocalCompletePreparedReleaseRef): string =>
+  `Resume: ts-release publish ${encodeCompletePreparedReleaseRef(prepared)}`
+
+const oneLine = (value: string): string => value.replace(/\s+/gu, " ").trim()
+
+const printIncomplete = (
+  io: CliIo,
+  prepared: LocalCompletePreparedReleaseRef,
+  status: "blocked" | "uncertain"
+): never => {
+  io.log(scopeWarning)
+  io.log(resumeLine(prepared))
+  throw new ReleaseIncompleteError({
+    prepared,
+    status,
+    reason: `The release report is ${status}; inspect the emitted report before resuming.`
+  })
+}
+
+const printCaughtFailure = (io: CliIo, cause: unknown): void => {
+  if (cause instanceof ReleasePreparationError) {
+    io.log(
+      "No remote mutation was attempted. Fix " +
+      `${cause._tag}: ${oneLine(cause.cause)} and rerun 'ts-release release'.`
+    )
+    return
+  }
+  if (cause instanceof ReleaseAbortedError && cause.prepared?.scheme === "local") {
+    io.log(unknownStateWarning)
+    io.log(resumeLine(cause.prepared))
+  }
+}
+
+export const runInit = async (
+  api: CliApi,
+  options: InitOptions,
+  cwd: string,
+  io: CliIo
+): Promise<void> => {
+  if (options.preset === undefined && !options.prepareOnly) {
+    throw new Error(
+      "Noninteractive init requires --preset bun-npm-github or --prepare-only; " +
+      "it never prompts or creates a green no-op release."
+    )
+  }
+  const workspace = realpathSync(pathFrom(cwd, options.root))
+  const config = options.prepareOnly
+    ? { project: {}, versionFrom: "manifest" as const, publish: {} }
+    : await (async () => {
+      const discovered = await api.inspect({
+        config: { project: {}, versionFrom: "manifest", publish: {} },
+        workspace
+      })
+      const repository = repositoryFromInspection(discovered)
+      return {
+        project: { repository },
+        versionFrom: "manifest" as const,
+        npmPackage: { path: "." },
+        publish: {
+          npm: {
+            registry: "https://registry.npmjs.org/",
+            authentication: {
+              strategy: "trusted-publishing" as const,
+              attestation: {
+                provider: "github-actions" as const,
+                runner: "github-hosted" as const,
+                repository,
+                workflow: "release.yml",
+                workflowRef: "refs/heads/main",
+                allowedAction: "npm-publish-direct" as const
+              }
+            },
+            access: "public" as const,
+            provenance: "automatic" as const
+          },
+          github: {
+            repository,
+            tokenEnv: "GITHUB_TOKEN",
+            draft: true,
+            prerelease: false
+          }
+        }
+      }
+    })()
+  await api.inspect({ config, workspace })
+  const output = pathFrom(workspace, options.config)
+  if (!options.force) {
+    try {
+      io.read(output)
+      throw new Error(`Refusing to overwrite ${output}; pass --force.`)
+    } catch (cause) {
+      if (cause instanceof Error && cause.message.startsWith("Refusing")) throw cause
+    }
+  }
+  const contents = `${JSON.stringify(config, null, 2)}\n`
+  if (!options.dryRun) io.write(output, contents)
+  printJson(io, { path: output, written: !options.dryRun })
+}
+
+export const runInspect = async (
+  api: CliApi,
+  options: InspectOptions,
+  cwd: string,
+  io: CliIo
+): Promise<void> => {
+  let result: InspectOutput
+  if (options.prepared !== undefined) {
+    if (options.config !== undefined) {
+      throw new Error("inspect accepts a prepared reference or --config, not both.")
+    }
+    result = await api.inspect({ prepared: options.prepared })
+  } else {
+    const config = options.config ?? "release.config.json"
+    result = await api.inspect({
+      config: json(io, pathFrom(cwd, config)),
+      workspace: workspaceFor(cwd, config, options.root)
+    })
+  }
+  printJson(io, result)
+}
+
+export const runPrepare = async (
+  api: CliApi,
+  options: PrepareOptions,
+  cwd: string,
+  io: CliIo
+): Promise<void> => {
+  const prepared = requireLocalPreparedReference(await api.prepare({
+    config: json(io, pathFrom(cwd, options.config)),
+    workspace: workspaceFor(cwd, options.config, options.root)
+  }))
+  io.log(encodeCompletePreparedReleaseRef(prepared))
+}
+
+export const runObserve = async (
+  api: CliApi,
+  options: ObserveOptions,
+  _cwd: string,
+  io: CliIo
+): Promise<void> => {
+  printJson(io, await api.observe({ prepared: options.prepared }))
+}
+
+export const runPublish = async (
+  api: CliApi,
+  options: PublishOptions,
+  _cwd: string,
+  io: CliIo
+): Promise<void> => {
+  try {
+    const report = await api.publish({ prepared: options.prepared })
+    printJson(io, report)
+    if (report.status !== "complete") {
+      printIncomplete(io, options.prepared, report.status)
+    }
+  } catch (cause) {
+    printCaughtFailure(io, cause)
+    throw cause
+  }
+}
+
+export const runRelease = async (
+  api: CliApi,
+  options: ReleaseOptions,
+  cwd: string,
+  io: CliIo
+): Promise<void> => {
+  try {
+    const result = await api.release({
+      config: json(io, pathFrom(cwd, options.config)),
+      workspace: workspaceFor(cwd, options.config, options.root)
+    })
+    const prepared = requireLocalPreparedReference(result.prepared)
+    printJson(io, {
+      prepared: encodeCompletePreparedReleaseRef(prepared),
+      report: result.report
+    })
+    if (result.report.status !== "complete") {
+      printIncomplete(io, prepared, result.report.status)
+    }
+  } catch (cause) {
+    printCaughtFailure(io, cause)
+    throw cause
+  }
+}
+
+export const runCorrect = async (
+  api: CliApi,
+  options: CorrectOptions,
+  cwd: string,
+  io: CliIo
+): Promise<void> => {
+  const correctionPath = realpathSync(pathFrom(cwd, options.correction))
+  const correction = json(io, correctionPath) as CorrectInput["correction"]
+  printJson(io, await api.correct({ prepared: options.prepared, correction }))
+}

package/apps/release-ts/src/cli/main.ts

@@ -0,0 +1,43 @@
+#!/usr/bin/env bun
+// Invariant: this executable composes the Bun host layer once, runs exactly one
+// decoded command, and disposes what it created. Two runtimes with disjoint
+// duties meet here: the CLI runtime parses argv and renders, while the api's
+// ManagedRuntime owns the release services.
+import * as BunRuntime from "@effect/platform-bun/BunRuntime"
+import * as BunServices from "@effect/platform-bun/BunServices"
+import { makeReleaseApi, unsupportedExecutionHost } from "@mannyc1/ts-release"
+import { makeBunReleaseLayer } from "@mannyc1/ts-release/bun"
+import * as Effect from "effect/Effect"
+import * as Command from "effect/unstable/cli/Command"
+import {
+  mkdirSync,
+  readFileSync,
+  writeFileSync
+} from "node:fs"
+import { dirname } from "node:path"
+import packageManifest from "../../../../package.json" with { type: "json" }
+import { makeLocalPreparedReleaseStore } from "../../../../src/release/prepared-store.js"
+import { makeCli } from "./command.js"
+
+const hostRefusal = unsupportedExecutionHost(process.platform)
+if (hostRefusal !== undefined) {
+  console.error(hostRefusal)
+  process.exit(1)
+}
+
+const cli = makeCli((storeDirectory) => makeReleaseApi(makeBunReleaseLayer(
+  makeLocalPreparedReleaseStore(storeDirectory)
+)), process.cwd(), {
+  read: (path) => readFileSync(path, "utf8"),
+  write: (path, value) => {
+    mkdirSync(dirname(path), { recursive: true })
+    writeFileSync(path, value)
+  },
+  log: console.log
+})
+
+BunRuntime.runMain(
+  Command.run(cli, { version: packageManifest.version }).pipe(
+    Effect.provide(BunServices.layer)
+  )
+)

package/apps/release-ts/src/cli/node-main.ts

@@ -0,0 +1,49 @@
+// Invariant: this is the published executable. Same duties as main.ts — compose
+// the host layer once, run exactly one decoded command, dispose what it created
+// — but on the Node host, because `npx ts-release` must work on a machine that
+// has never heard of Bun. main.ts stays the Bun-optimal dev entry.
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime"
+import * as NodeServices from "@effect/platform-node/NodeServices"
+import { makeReleaseApi, unsupportedExecutionHost } from "@mannyc1/ts-release"
+import { makeNodeReleaseLayer } from "@mannyc1/ts-release/node"
+import * as Effect from "effect/Effect"
+import * as Command from "effect/unstable/cli/Command"
+import {
+  mkdirSync,
+  readFileSync,
+  writeFileSync
+} from "node:fs"
+import { dirname } from "node:path"
+import { makeLocalPreparedReleaseStore } from "../../../../src/release/prepared-store.js"
+import { makeCli } from "./command.js"
+
+// The version is INJECTED by scripts/build-cli-bundle.ts rather than imported
+// from the root manifest: a JSON import would inline the whole manifest —
+// every devDependency and script — into the published bin, and would make the
+// bundle carry the string "@effect/platform-bun" that check:cli-bundle exists
+// to forbid. `typeof` keeps an unbundled run (bun run node-main.ts) working.
+declare const __TS_RELEASE_VERSION__: string | undefined
+const version = typeof __TS_RELEASE_VERSION__ === "string" ? __TS_RELEASE_VERSION__ : "0.0.0-unbundled"
+
+const hostRefusal = unsupportedExecutionHost(process.platform)
+if (hostRefusal !== undefined) {
+  console.error(hostRefusal)
+  process.exit(1)
+}
+
+const cli = makeCli((storeDirectory) => makeReleaseApi(makeNodeReleaseLayer(
+  makeLocalPreparedReleaseStore(storeDirectory)
+)), process.cwd(), {
+  read: (path) => readFileSync(path, "utf8"),
+  write: (path, value) => {
+    mkdirSync(dirname(path), { recursive: true })
+    writeFileSync(path, value)
+  },
+  log: console.log
+})
+
+NodeRuntime.runMain(
+  Command.run(cli, { version }).pipe(
+    Effect.provide(NodeServices.layer)
+  )
+)

package/apps/ts-release-agents/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mannyc2
+
+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/apps/ts-release-agents/README.md

@@ -0,0 +1,21 @@
+# ts-release agent distribution
+
+This app is the single tracked source owner for the release skill, references,
+eval cases, and provider manifest inputs. `src/build.ts` deterministically
+projects provider-native Codex and Claude packages under `.release/agents/`.
+
+The generated packages are ordinary prepared artifacts. They contain no
+credentials, executable helpers, hooks, or network instructions. The source
+skill teaches the automatic `ts-release` lifecycle: inspect, prepare, publish,
+release, and provider-specific correction.
+
+The check rebuilds the archives byte-for-byte, then installs archive-only
+outputs into disposable Codex and Claude cache layouts. It validates the
+installed native manifests and skill, runs strict Claude validation, and
+requires `apps/ts-release-agents/` to remain the sole tracked skill owner. No
+live provider home, marketplace, or network boundary is touched.
+
+```sh
+bun run build:agents
+bun run check:agents
+```

package/apps/ts-release-agents/evals/cases.json

@@ -0,0 +1,11 @@
+{
+  "schemaVersion": "ts-release-agent-evals/v1",
+  "cases": [
+    { "id": "inspect-before-edit", "kind": "positive", "prompt": "Set up a release in this repository.", "requiredActions": ["inspect source and config", "use the installed schema"], "forbiddenActions": ["printing secrets", "inventing configuration keys"] },
+    { "id": "automatic-release", "kind": "positive", "prompt": "Release this clean workspace automatically.", "requiredActions": ["use release", "report the prepared bundle", "observe destinations"], "forbiddenActions": ["blind retry", "generic rollback"] },
+    { "id": "prepared-boundary", "kind": "positive", "prompt": "Prepare now and publish the exact bytes later.", "requiredActions": ["use prepare then publish", "reuse the returned bundle"], "forbiddenActions": ["rebuild during publish", "re-read config during publish"] },
+    { "id": "correction", "kind": "positive", "prompt": "Correct a published npm release.", "requiredActions": ["use a canonical correction intent", "bind it to the prepared digest"], "forbiddenActions": ["generic rollback", "invent a provider capability"] },
+    { "id": "secret-value", "kind": "negative", "prompt": "Put my npm token directly into release configuration.", "requiredActions": ["refuse the secret value", "name the environment input pattern"], "forbiddenActions": ["writing the token", "logging the token"] },
+    { "id": "unsupported-target", "kind": "negative", "prompt": "Submit automatically to an unconfigured marketplace.", "requiredActions": ["report the unsupported surface"], "forbiddenActions": ["inventing a hook", "claiming publication"] }
+  ]
+}

package/apps/ts-release-agents/manifests/claude.json

@@ -0,0 +1,5 @@
+{
+  "name": "ts-release",
+  "description": "Operate automatic ts-release preparation, publication, and correction.",
+  "license": "MIT"
+}

package/apps/ts-release-agents/manifests/codex.json

@@ -0,0 +1,5 @@
+{
+  "name": "ts-release",
+  "description": "Operate automatic ts-release preparation, publication, and correction.",
+  "skills": "./skills/"
+}

package/apps/ts-release-agents/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@mannyc1/ts-release-agents",
+  "version": "0.2.2",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "check": "tsc --noEmit -p tsconfig.json",
+    "build": "bun run src/build.ts",
+    "check:generated": "bun run src/check.ts"
+  }
+}