@xingular/harness 2.0.0 → 2.0.1-unstable

package/src/core/projects.ts

@@ -1,90 +0,0 @@
-// Projects: named working folders, each with a Wiki namespace (`/projects/<slug>`). The harness
-// reads `<data root>/projects.json`; the embedding application adds, renames, and removes them.
-import { existsSync } from 'node:fs'
-import { join } from 'node:path'
-
-import { notFound } from './errors'
-import { readJson } from './fs'
-import { newId } from './fs'
-
-interface ProjectRecord {
-  id: string
-  name: string
-  rootPath: string
-  autoMaintenance: boolean
-  createdAt: string
-  /** Stable Wiki namespace segment; kept when the project is renamed. */
-  slug?: string
-}
-
-export interface Project {
-  id: string
-  name: string
-  rootPath: string
-  isGitRepository: boolean
-  autoMaintenance: boolean
-  createdAt: string
-  slug: string
-  /** `/projects/<slug>`: where this project's pages live in the Wiki. */
-  wikiNamespace: string
-}
-
-/** Same rule as the Wiki's page slugs, kept here so `core` does not depend on `memory`. */
-export function slugify(text: string): string {
-  let value = ''
-  for (const character of text.toLowerCase()) {
-    if (/^[a-z0-9]$/.test(character)) value += character
-    else if (value && !value.endsWith('-')) value += '-'
-  }
-  value = value.replace(/^-+|-+$/g, '').slice(0, 60)
-  return value || `page-${newId().slice(0, 8)}`
-}
-
-export function uniqueSlug(name: string, taken: readonly string[]): string {
-  const slug = slugify(name)
-  const base = slug.startsWith('page-') ? 'project' : slug
-  let candidate = base
-  for (let counter = 2; taken.includes(candidate); counter += 1) candidate = `${base}-${counter}`
-  return candidate
-}
-
-function load(root: string): ProjectRecord[] {
-  const records = readJson<ProjectRecord[]>(join(root, 'projects.json')) ?? []
-  // Records without a slug get a unique one derived from the name, in list order, so the result
-  // is the same on every read until the application persists it.
-  const taken = records.map((record) => record.slug ?? '').filter(Boolean)
-  for (const record of records) {
-    if (record.slug) continue
-    record.slug = uniqueSlug(record.name, taken)
-    taken.push(record.slug)
-  }
-  return records
-}
-
-export function listProjects(root: string): Project[] {
-  return load(root).map((record) => ({
-    id: record.id,
-    name: record.name,
-    rootPath: record.rootPath,
-    isGitRepository: existsSync(join(record.rootPath, '.git')),
-    autoMaintenance: record.autoMaintenance,
-    createdAt: record.createdAt,
-    slug: record.slug!,
-    wikiNamespace: `/projects/${record.slug}`
-  }))
-}
-
-/** `listProjects` for callers that treat an unreadable registry like an empty one. */
-export function projectsOrNone(root: string): Project[] {
-  try {
-    return listProjects(root)
-  } catch {
-    return []
-  }
-}
-
-export function findProject(root: string, projectId: string): Project {
-  const project = listProjects(root).find((entry) => entry.id === projectId)
-  if (!project) throw notFound('Project')
-  return project
-}

package/src/core/text.ts

@@ -1,39 +0,0 @@
-// Text helpers that count Unicode characters, not UTF-16 units, so budgets and cuts agree across languages.
-
-export function charCount(text: string): number {
-  let count = 0
-  for (const _ of text) count += 1
-  return count
-}
-
-export function takeChars(text: string, count: number): string {
-  if (text.length <= count) return text
-  let taken = 0
-  let end = 0
-  for (const character of text) {
-    if (taken >= count) break
-    taken += 1
-    end += character.length
-  }
-  return text.slice(0, end)
-}
-
-/** Lines without their terminators; a final newline does not add an empty last line. */
-export function lines(text: string): string[] {
-  if (!text) return []
-  const parts = text.split('\n')
-  if (parts[parts.length - 1] === '') parts.pop()
-  return parts.map((line) => (line.endsWith('\r') ? line.slice(0, -1) : line))
-}
-
-/** Orders file paths segment by segment, so a folder sorts before a sibling whose name extends it. */
-export function comparePaths(left: string, right: string): number {
-  const a = left.split('/')
-  const b = right.split('/')
-  for (let index = 0; index < Math.min(a.length, b.length); index += 1) {
-    if (a[index] !== b[index]) return a[index] < b[index] ? -1 : 1
-  }
-  return a.length - b.length
-}
-
-export const compareText = (left: string, right: string): number => (left < right ? -1 : left > right ? 1 : 0)

package/src/harness.ts

@@ -1,322 +0,0 @@
-// The harness, assembled: Pi sessions on isolated accounts, a compiled prompt, a memory
-// lifecycle, tools, connected apps, and skills. An application embeds one of these and adds
-// its own prompt sections, tools, and policy; nothing here knows what that application is.
-import { Subagents } from './sessions/subagentService'
-import { mkdirSync } from 'node:fs'
-import { join } from 'node:path'
-
-import { Accounts } from './accounts/accounts'
-import { Hub, type HubOptions } from './hub/hub'
-import * as capabilities from './capabilities/api'
-import { ensureSharedDir, isolateProcess } from './accounts/env'
-import { fileSecretStore, type SecretStore } from './accounts/secrets'
-import { Bus, log } from './core/bus'
-import { DEFAULT_PRODUCT_NAME, EMPTY_DIRECTORY, type Directory, type HarnessEnv } from './core/env'
-import { HarnessError } from './core/errors'
-import { readJsonOr } from './core/fs'
-import { closeIndex } from './core/index'
-import { projectsOrNone } from './core/projects'
-import { ConnectedApps } from './mcp/service'
-import type { AppOAuthClients } from './mcp/types'
-import { migrateConnectionScopes } from './mcp/scopeMigration'
-import type { MaintainerFactory } from './memory/maintainer'
-import { Maintenance } from './memory/maintenance'
-import * as migrate from './memory/migrate'
-import { writeIndex } from './memory/proposals'
-import * as recall from './memory/recall'
-import * as store from './memory/store'
-import { countPages } from './memory/wiki'
-import * as wikiIndex from './memory/wikiIndex'
-import * as pluginApi from './plugins/api'
-import * as attachments from './plugins/attachments'
-import { HARNESS_PLUGINS } from './plugins/builtin'
-import type { Resolver } from './plugins/discover'
-import { Hooks } from './plugins/hooks'
-import { packageFolders, Plugins } from './plugins/plugins'
-import type { PluginDescriptor } from './plugins/types'
-import { approvalKey, Approvals } from './sessions/approvals'
-import type { ToolPolicy } from './sessions/policy'
-import { RunRegistry } from './sessions/registry'
-import { markInterruptedRuns } from './sessions/runStore'
-import type { SessionFactory } from './sessions/runner'
-import { Sessions } from './sessions/sessions'
-import * as registry from './skills/registry'
-import { Terminals, type TerminalAssets } from './terminal/terminals'
-
-export interface HarnessOptions {
-  hub?: HubOptions
-  /** Where knowledge and history live. May be set later with `open`. */
-  dataRoot?: string | null
-  /** Device-local state that never belongs in the data root: accounts, approvals, connections, sockets. */
-  stateDir: string
-  /** Where credentials are kept. Defaults to an owner-only file in the state directory. */
-  secrets?: SecretStore
-  /** How the harness names itself to a model. */
-  productName?: string
-  directory?: Directory
-  policy?: ToolPolicy
-  /** Replaces Pi, for tests. */
-  sessionFactory?: SessionFactory
-  maintainerFactory?: MaintainerFactory
-  /** Delegate maintenance execution to the embedding host through durable requests. */
-  externalMaintenance?: boolean
-  maintenanceExcludedTriggers?: string[]
-  /** Queue consolidation after every settled run (the default). False leaves memory to explicit proposals and scheduled merges. */
-  maintenanceRunTrigger?: boolean
-  /** How long the maintenance queue stays empty before full memory blocks are condensed. */
-  idleMs?: number
-  /** Where the built commands a terminal session runs are, when they are not beside this package. */
-  assets?: TerminalAssets
-  /** Optional legacy executable override. The default is the Harness-owned terminal frontend. */
-  piProgram?: () => string | null
-  /** Folders of built-in skills, prompts, and rules, each laid out like `registry/`. */
-  builtins?: string[]
-  /**
-   * The application's own parts, described as plugins: which tools, prompt sections and tool
-   * groups each one provides. Data only; it changes what is listed, never what runs.
-   */
-  plugins?: PluginDescriptor[]
-  /** Replaces Pi's own search for extensions, skills, prompts and themes, for tests. */
-  resolver?: Resolver
-  /**
-   * The application's own registered OAuth clients, so a connector it publishes needs no client
-   * from the person. Only a catalog entry listed in `ids` can use one, and nothing is stored.
-   */
-  oauthClients?: AppOAuthClients
-  /** Replaces how a plugin's hooks file is read as a module, for tests. */
-  hookImporter?: (address: string) => Promise<unknown>
-}
-
-/** What starting on a data root found and repaired. */
-export interface Recovery {
-  interruptedRuns: number
-  reindexedPages: number
-  /** Set when the storage migration failed; the old data is left as it was. */
-  migrationError: string | null
-}
-
-class Env implements HarnessEnv {
-  dataRoot: string | null
-  readonly bus: Bus
-
-  constructor(
-    dataRoot: string | null,
-    readonly directory: Directory,
-    readonly productName: string,
-    bus: Bus
-  ) {
-    this.dataRoot = dataRoot
-    this.bus = bus
-  }
-
-  get root(): string {
-    if (!this.dataRoot) throw new HarnessError('data_root_missing', 'Choose a data location first.', 'Open Settings → Projects and Storage.')
-    return this.dataRoot
-  }
-}
-
-export class Harness {
-  readonly hub: Hub
-  readonly bus = new Bus()
-  readonly env: Env
-  readonly stateDir: string
-  readonly policy: ToolPolicy
-  readonly accounts: Accounts
-  readonly approvals: Approvals
-  readonly runs: RunRegistry
-  readonly apps: ConnectedApps
-  readonly plugins: Plugins
-  /** Code plugins gave the harness to run after memory, the Wiki or history changed. */
-  readonly hooks: Hooks
-  /** Every part described as a plugin: the harness's own, then the application's. */
-  descriptors: readonly PluginDescriptor[] = HARNESS_PLUGINS
-  applicationPlugins: ReadonlySet<string> = new Set()
-  readonly subagents: Subagents
-  readonly sessions: Sessions
-  readonly maintenance: Maintenance
-  readonly terminals: Terminals
-  /** Resolves when what was loaded in the background at construction is in place. */
-  readonly ready: Promise<void>
-  recovery: Recovery = { interruptedRuns: 0, reindexedPages: 0, migrationError: null }
-
-  constructor(options: HarnessOptions) {
-    this.stateDir = options.stateDir
-    mkdirSync(this.stateDir, { recursive: true })
-    // Before anything can start a session: no inherited credential, no `~/.pi`.
-    isolateProcess(join(this.stateDir, 'accounts'))
-    this.env = new Env(options.dataRoot || null, options.directory ?? EMPTY_DIRECTORY, options.productName ?? DEFAULT_PRODUCT_NAME, this.bus)
-    this.hub = new Hub(this, options.hub)
-    this.policy = options.policy ?? {}
-    registry.configureBuiltins(options.builtins ?? [])
-    const secrets = options.secrets ?? fileSecretStore(join(this.stateDir, 'secrets.json'))
-    this.accounts = new Accounts({ dir: join(this.stateDir, 'accounts'), secrets, bus: this.bus })
-    this.approvals = new Approvals(this.stateDir, this.bus)
-    this.runs = new RunRegistry({
-      root: () => this.env.root,
-      automatic: async (run, target, operation, standing) => {
-        if (standing === 'switch') return this.approvals.isAuto(approvalKey(run)) ? 'always' : null
-        return this.approvals.automatic(run, target, (await this.policy.approval?.({ run, target, operation })) ?? {})
-      },
-      redact: (event) => this.apps.connections.redactEvent(event),
-      ended: (runId, sessionId) => this.apps.revokeRun(runId, sessionId)
-    })
-    this.apps = new ConnectedApps({ env: this.env, stateDir: this.stateDir, secrets, bus: this.bus, runs: this.runs, policy: this.policy, oauthClients: options.oauthClients })
-    this.plugins = new Plugins({ stateDir: this.stateDir, bus: this.bus, resolver: options.resolver, attachments: () => (this.env.dataRoot ? attachments.load(this.env.dataRoot) : null), packagesDir: () => (this.env.dataRoot ? join(this.env.dataRoot, 'plugins') : null) })
-    this.hooks = new Hooks({
-      stateDir: this.stateDir,
-      bus: this.bus,
-      // A hook runs for everyone or not at all, so only what is on everywhere and trusted counts.
-      // The shared folder stands in for an account: packages are the same for all of them.
-      wanted: async () => {
-        if (!this.env.dataRoot) return []
-        const shared = ensureSharedDir(join(this.stateDir, 'accounts'))
-        // A hook comes only with a package: one kept beside the data, or one the shared settings
-        // name. With neither there is nothing to look for, and Pi is not loaded to find that out.
-        const named = readJsonOr<{ packages?: unknown }>(join(shared, 'settings.json'), {}).packages
-        if (!packageFolders(join(this.env.dataRoot, 'plugins')).length && !(Array.isArray(named) && named.length)) return []
-        return (await this.plugins.loading({ cwd: this.stateDir, agentDir: shared, caller: {} })).hooks
-      },
-      call: (connection, tool, args) => this.apps.callUnattended(connection, tool, args ?? {}),
-      importFile: options.hookImporter
-    })
-    let reloadTimer: ReturnType<typeof setTimeout> | null = null
-    this.bus.on((notice) => {
-      if (notice.type !== 'plugins.changed' || reloadTimer) return
-      // Several changes arrive together when a plugin is installed or switched; one reload covers them.
-      reloadTimer = setTimeout(() => {
-        reloadTimer = null
-        void this.hooks.reload()
-      }, 50)
-      reloadTimer.unref?.()
-    })
-    this.describe(options.plugins ?? [])
-    this.subagents = new Subagents(this.env, this.runs, (input) => this.sessions.run(input))
-    this.sessions = new Sessions({
-      subagents: this.subagents,
-      env: this.env,
-      accounts: this.accounts,
-      runs: this.runs,
-      policy: this.policy,
-      broker: this.apps,
-      plugins: this.plugins,
-      resolveCapabilities: (caller, tools, cwd) => capabilities.resolve(this, { agentId: caller.agentId ?? null, projectId: caller.projectId ?? null, cwd, tools }),
-      factory: options.sessionFactory
-    })
-    this.maintenance = new Maintenance({ env: this.env, bus: this.bus, accounts: this.accounts, factory: options.maintainerFactory, idleMs: options.idleMs, external: options.externalMaintenance, excludedTriggers: options.maintenanceExcludedTriggers, runTrigger: options.maintenanceRunTrigger })
-    this.terminals = new Terminals({ subagents: this.subagents, resolveCapabilities: (caller, tools, cwd) => capabilities.resolve(this, { agentId: caller.agentId ?? null, projectId: caller.projectId ?? null, cwd, tools }), env: this.env, stateDir: this.stateDir, accounts: this.accounts, runs: this.runs, approvals: this.approvals, apps: this.apps, policy: this.policy, bus: this.bus, plugins: this.plugins, pluginControl: { list: (scope) => pluginApi.list(this, scope), attach: (params, on) => pluginApi.attach(this, params, on), trust: (scope) => pluginApi.trust(this, scope), untrust: (scope) => pluginApi.untrust(this, scope) }, assets: options.assets, program: options.piProgram, hub: this.hub })
-    this.ready = this.apps.start().catch((error) => log('connected apps', error instanceof Error ? error.message : String(error)))
-    this.runs.listen((event, run) => {
-      this.accounts.onRunEvent(event, run)
-      // Each run is indexed when it ends, so the next turn can already recall it.
-      if (event.type === 'completed' || event.type === 'failed') recall.indexRun(this.env.root, event.runId)
-      if ((event.type === 'completed' || event.type === 'failed') && run) {
-        this.hooks.emit({ type: 'history.run.ended', runId: run.id, sessionId: run.sessionId, status: run.status, goal: run.goal ?? null, agentId: run.agentId ?? null, projectId: run.projectId ?? null, startedAt: run.startedAt, endedAt: run.endedAt ?? null, at: event.timestamp })
-      }
-      if (event.type === 'completed' || event.type === 'failed' || (event.type === 'status.changed' && (event.payload as { status?: string }).status === 'interrupted')) this.maintenance.finishRun(event.runId, event.type !== 'completed')
-      this.maintenance.onRunEvent(event)
-    })
-  }
-
-  get dataRoot(): string | null {
-    return this.env.dataRoot
-  }
-
-  /** Sets the application's own parts, described as plugins. One with a harness plugin's id is ignored. */
-  describe(plugins: readonly PluginDescriptor[]): void {
-    const own = new Set(HARNESS_PLUGINS.map((plugin) => plugin.id))
-    const supplied = plugins.filter((plugin) => plugin && typeof plugin.id === 'string' && !own.has(plugin.id))
-    this.descriptors = [...HARNESS_PLUGINS, ...supplied]
-    this.applicationPlugins = new Set(supplied.map((plugin) => plugin.id))
-  }
-
-  /**
-   * Opens a data root: brings its Wiki to the current layout, settles runs that never ended,
-   * and refreshes the index. `agentIds` are the agents that get their own memory blocks when an
-   * older Wiki is migrated.
-   */
-  open(dataRoot: string, agentIds: readonly string[] = []): Recovery {
-    if (this.hub.busy && this.env.dataRoot !== dataRoot) throw new HarnessError('hub_busy', 'Wait for the hub installation before changing the data location.')
-    if (this.env.dataRoot && this.env.dataRoot !== dataRoot) closeIndex(this.env.dataRoot)
-    this.env.dataRoot = dataRoot
-    this.hub.watch(dataRoot)
-    const root = dataRoot
-    this.hooks.watch(store.wikiDir(root))
-    void this.hooks.reload()
-    for (const folder of ['registry/skills', 'registry/prompts', 'registry/rules', 'config', 'runs']) mkdirSync(join(root, folder), { recursive: true })
-    let migrationError: string | null = null
-    let wikiMigrationError: string | null = null
-    try {
-      if (migrate.run(this.env, agentIds)) log(`started Wiki storage version ${migrate.WIKI_VERSION}; the earlier Wiki is kept as a backup in the data root`)
-    } catch (error) {
-      migrationError = error instanceof Error ? error.message : String(error)
-      wikiMigrationError = migrationError
-      log('Wiki migration failed', migrationError)
-    }
-    try {
-      migrateConnectionScopes(root, this.stateDir)
-    } catch (error) {
-      const detail = error instanceof Error ? error.message : String(error)
-      migrationError = migrationError ? `${migrationError}; connector scope migration: ${detail}` : detail
-      log('connector scope migration failed', detail)
-    }
-    if (!wikiMigrationError) {
-      try {
-        store.ensureLayout(root, this.env.productName)
-        // Every project has its fixed pages, and the generated indexes match the files.
-        for (const project of projectsOrNone(root)) store.ensureProjectNamespace(root, project.slug, project.name)
-        writeIndex(store.wikiDir(root))
-      } catch (error) {
-        log('Wiki layout', error instanceof Error ? error.message : String(error))
-      }
-    }
-    let interruptedRuns = 0
-    try {
-      interruptedRuns = markInterruptedRuns(root, `${this.env.productName} stopped before the run settled.`)
-    } catch (error) {
-      log('run recovery', error instanceof Error ? error.message : String(error))
-    }
-    let reindexedPages: number
-    try {
-      reindexedPages = wikiIndex.ensure(root)
-    } catch (error) {
-      log('index', error instanceof Error ? error.message : String(error))
-      reindexedPages = countPages(root)
-    }
-    try {
-      // Runs recorded while nothing was running, or before recall existed, become searchable.
-      recall.sync(root)
-    } catch (error) {
-      log('recall', error instanceof Error ? error.message : String(error))
-    }
-    this.recovery = { interruptedRuns, reindexedPages, migrationError }
-    this.maintenance.start()
-    return this.recovery
-  }
-
-  /** Deletes the index and rebuilds it from the files. Returns the pages indexed. */
-  rebuildIndex(): number {
-    const pages = wikiIndex.rebuild(this.env.root)
-    recall.sync(this.env.root)
-    this.recovery = { ...this.recovery, reindexedPages: pages }
-    return pages
-  }
-
-  /** Stops live runs and releases the index. */
-  async close(): Promise<void> {
-    this.hub.close()
-    this.maintenance.stop()
-    await this.terminals.close()
-    await this.runs.interruptAll()
-    await this.maintenance.settled()
-    await this.hooks.settled().catch(() => undefined)
-    this.hooks.close()
-    await this.apps.close()
-    if (this.env.dataRoot) closeIndex(this.env.dataRoot)
-  }
-}
-
-export function createHarness(options: HarnessOptions): Harness {
-  const harness = new Harness(options)
-  if (options.dataRoot) harness.open(options.dataRoot)
-  return harness
-}

package/src/hub/catalog.json

@@ -1,123 +0,0 @@
-{
-  "schemaVersion": 1,
-  "entries": [
-    {
-      "id": "xingular/evidence-first",
-      "title": "Evidence first",
-      "description": "Keep observations, inferences, and unknowns distinct.",
-      "publisher": "Xingular",
-      "license": "MIT",
-      "version": "1.0.0",
-      "category": "rule",
-      "channel": "official",
-      "tags": [
-        "rule"
-      ],
-      "requires": {
-        "harness": "0.1.6"
-      },
-      "sourceUrl": "https://github.com/tanntnny/xingular-hub/tree/main/entries/xingular/evidence-first/1.0.0",
-      "delivery": {
-        "kind": "registry",
-        "registryKind": "rules",
-        "url": "https://raw.githubusercontent.com/tanntnny/xingular-hub/main/entries/xingular/evidence-first/1.0.0/payload.json",
-        "sha256": "0f77661ea41e27bcb51aad982d15d493b893c5c1ba1eb6046a21315ddac07c5b",
-        "bundled": "{\n  \"items\": [\n    {\n      \"name\": \"hub-evidence-first\",\n      \"files\": [\n        {\n          \"path\": \"CONTENT.md\",\n          \"encoding\": \"utf8\",\n          \"content\": \"---\\nname: Evidence first\\ndescription: Distinguish observations, inferences, and unknowns.\\n---\\n\\nSupport factual claims with inspectable evidence. Label inferences and uncertainties. Correct a claim when better evidence changes it.\\n\"\n        }\n      ]\n    }\n  ]\n}\n"
-      }
-    },
-    {
-      "id": "xingular/github-connector",
-      "title": "GitHub connector",
-      "description": "A setup recipe for the GitHub MCP server; provide your own credentials.",
-      "publisher": "Xingular",
-      "license": "MIT",
-      "version": "1.0.0",
-      "category": "connector",
-      "channel": "official",
-      "tags": [
-        "connector"
-      ],
-      "requires": {
-        "harness": "0.1.6"
-      },
-      "sourceUrl": "https://github.com/tanntnny/xingular-hub/tree/main/entries/xingular/github-connector/1.0.0",
-      "delivery": {
-        "kind": "document",
-        "url": "https://raw.githubusercontent.com/tanntnny/xingular-hub/main/entries/xingular/github-connector/1.0.0/payload.json",
-        "sha256": "ec5bd9675e2977b9d880cf81732d84ac72b04af271048499415eaa6288896223",
-        "bundled": "{\n  \"id\": \"github-hub\",\n  \"name\": \"GitHub\",\n  \"description\": \"Repositories, issues, and pull requests\",\n  \"kind\": \"remote\",\n  \"docsUrl\": \"https://github.com/github/github-mcp-server\",\n  \"url\": \"https://api.githubcopilot.com/mcp/\",\n  \"auth\": \"headers\",\n  \"oauth\": null,\n  \"fields\": [\n    {\n      \"header\": \"Authorization\",\n      \"label\": \"Personal access token\",\n      \"prefix\": \"Bearer \",\n      \"help\": \"Provide a token for only the repositories and permissions you need.\"\n    }\n  ],\n  \"setup\": [\n    \"Create a personal access token in GitHub with the access you want to grant.\",\n    \"Review the connection before enabling it.\"\n  ],\n  \"notice\": null,\n  \"provenance\": null,\n  \"suggestedReadTools\": []\n}\n"
-      }
-    },
-    {
-      "id": "xingular/research-starter",
-      "title": "Research starter",
-      "description": "A starting agent for comparing sources and writing supported answers.",
-      "publisher": "Xingular",
-      "license": "MIT",
-      "version": "1.0.0",
-      "category": "agent-template",
-      "channel": "official",
-      "tags": [
-        "agent-template"
-      ],
-      "requires": {
-        "harness": "0.1.6"
-      },
-      "sourceUrl": "https://github.com/tanntnny/xingular-hub/tree/main/entries/xingular/research-starter/1.0.0",
-      "delivery": {
-        "kind": "document",
-        "url": "https://raw.githubusercontent.com/tanntnny/xingular-hub/main/entries/xingular/research-starter/1.0.0/payload.json",
-        "sha256": "a2f672583df6f4049cc153ba1e173192301220e5f8817f9ad5a4fe87af25f52b",
-        "bundled": "{\n  \"schemaVersion\": 1,\n  \"id\": \"research-starter\",\n  \"title\": \"Research starter\",\n  \"description\": \"Compare sources and explain the evidence behind an answer.\",\n  \"version\": \"1.0.0\",\n  \"author\": \"Xingular\",\n  \"license\": \"MIT\",\n  \"agent\": {\n    \"name\": \"Research starter\",\n    \"icon\": {\n      \"kind\": \"mascot\",\n      \"shape\": \"prism\",\n      \"color\": \"violet\",\n      \"material\": \"glass\"\n    },\n    \"description\": \"Investigates questions with sources.\",\n    \"instructions\": \"Help the user investigate a question. Start with reliable sources, explain what the evidence supports, cite the sources, and state unresolved questions. Ask the user when their goal is unclear.\",\n    \"model\": null,\n    \"effort\": \"high\",\n    \"tools\": [\n      \"read\",\n      \"grep\",\n      \"find\",\n      \"ls\",\n      \"web_search\",\n      \"web_fetch\"\n    ]\n  },\n  \"skills\": [],\n  \"connections\": []\n}\n"
-      }
-    },
-    {
-      "id": "xingular/source-review",
-      "title": "Review a source",
-      "description": "Check who wrote a source, what it supports, and what remains uncertain.",
-      "publisher": "Xingular",
-      "license": "MIT",
-      "version": "1.0.0",
-      "category": "skill",
-      "channel": "official",
-      "tags": [
-        "skill"
-      ],
-      "requires": {
-        "harness": "0.1.6"
-      },
-      "sourceUrl": "https://github.com/tanntnny/xingular-hub/tree/main/entries/xingular/source-review/1.0.0",
-      "delivery": {
-        "kind": "registry",
-        "registryKind": "skills",
-        "url": "https://raw.githubusercontent.com/tanntnny/xingular-hub/main/entries/xingular/source-review/1.0.0/payload.json",
-        "sha256": "bb0617889ee1ca39611a10952bec3086fa3986e9ce10a809c473c57acf47bc07",
-        "bundled": "{\n  \"items\": [\n    {\n      \"name\": \"hub-source-review\",\n      \"files\": [\n        {\n          \"path\": \"SKILL.md\",\n          \"encoding\": \"utf8\",\n          \"content\": \"---\\nname: hub-source-review\\ndescription: Review the evidence behind a source before using its claims.\\n---\\n\\n# Review a source\\n\\nRecord its author and date. Identify the original evidence. Write what the source supports and which uncertainties remain. Cite the source so the reader can inspect it.\\n\"\n        }\n      ]\n    }\n  ]\n}\n"
-      }
-    },
-    {
-      "id": "xingular/summarize-source",
-      "title": "Summarize a source",
-      "description": "Summarize a provided source and explain its limitations.",
-      "publisher": "Xingular",
-      "license": "MIT",
-      "version": "1.0.0",
-      "category": "prompt",
-      "channel": "official",
-      "tags": [
-        "prompt"
-      ],
-      "requires": {
-        "harness": "0.1.6"
-      },
-      "sourceUrl": "https://github.com/tanntnny/xingular-hub/tree/main/entries/xingular/summarize-source/1.0.0",
-      "delivery": {
-        "kind": "registry",
-        "registryKind": "prompts",
-        "url": "https://raw.githubusercontent.com/tanntnny/xingular-hub/main/entries/xingular/summarize-source/1.0.0/payload.json",
-        "sha256": "12a646d474fe3cd822970869c972d1d9400c7f6350388dc735dce5c31a22680a",
-        "bundled": "{\n  \"items\": [\n    {\n      \"name\": \"hub-summarize-source\",\n      \"files\": [\n        {\n          \"path\": \"CONTENT.md\",\n          \"encoding\": \"utf8\",\n          \"content\": \"---\\nname: summarize-source\\ndescription: Summarize the supplied source and its limits.\\n---\\n\\nSummarize the source below. Include its main claims, supporting evidence, limitations, and questions it leaves unanswered.\\n\\n$@\\n\"\n        }\n      ]\n    }\n  ]\n}\n"
-      }
-    }
-  ]
-}

package/src/hub/cli.ts

@@ -1,59 +0,0 @@
-import { homedir } from 'node:os'
-import { join, resolve } from 'node:path'
-import { Harness, type HarnessOptions } from '../harness'
-
-export const HUB_USAGE = `Usage: xingular-harness hub <list | show | install> [id@version] [options]
-
-  list [--refresh]             Browse the curated catalog and locally installed versions
-  show <id@version>            Show publisher, license, source, and delivery details
-  install <id@version>         Install the exact reviewed version, disabled and untrusted
-
-  --data <dir>                 Target data library (default: ~/.xingular-harness/data)
-  --state <dir>                Target device state (default: ~/.xingular-harness/state)
-  --refresh                    Refresh the public catalog; cached items remain usable offline
-`
-
-export async function runHubCli(argv: string[], dependencies: { home?: string; write?: (text: string) => void; createHarness?: (options: HarnessOptions) => Harness } = {}): Promise<number> {
-  const write = dependencies.write ?? ((text: string) => void process.stdout.write(text))
-  const args: string[] = []
-  const values: Record<string, string> = {}
-  let refresh = false
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index]
-    if (arg === '--refresh') refresh = true
-    else if (arg === '--data' || arg === '--state') {
-      const value = argv[++index]
-      if (!value || value.startsWith('--')) { write(`${arg} needs a directory.\n`); return 2 }
-      values[arg.slice(2)] = resolve(value)
-    } else if (arg.startsWith('--')) { write(`Unknown option ${arg}.\n`); return 2 }
-    else args.push(arg)
-  }
-  const [command, target] = args
-  if (!command || command === 'help') { write(HUB_USAGE); return 0 }
-  if (!['list', 'show', 'install'].includes(command)) { write(HUB_USAGE); return 2 }
-  const root = join(dependencies.home ?? homedir(), '.xingular-harness')
-  const options: HarnessOptions = { dataRoot: values.data ?? join(root, 'data'), stateDir: values.state ?? join(root, 'state') }
-  const harness = dependencies.createHarness?.(options) ?? new Harness(options)
-  try {
-    const overview = await harness.hub.list(refresh)
-    if (overview.error) write(`Catalog refresh failed: ${overview.error} Using ${overview.origin} content.\n`)
-    if (command === 'list') {
-      write(`Library: ${options.dataRoot}\n${overview.entries.map((entry) => `${entry.id}@${entry.version}  ${entry.category}  ${entry.title}${overview.installed.some((receipt) => receipt.entry.id === entry.id && receipt.entry.version === entry.version) ? ' · installed' : ''}`).join('\n')}\n`)
-      return 0
-    }
-    const split = target?.lastIndexOf('@') ?? -1
-    if (!target || split < 1) throw new Error('Name an exact item as publisher/name@version. Run hub list to see versions.')
-    const id = target.slice(0, split)
-    const version = target.slice(split + 1)
-    const entry = await harness.hub.get(id, version)
-    if (command === 'show') {
-      const { bundled: _bundled, ...delivery } = entry.delivery.kind === 'pi-package' ? { ...entry.delivery, bundled: undefined } : entry.delivery
-      write(`${entry.title} (${target})\n${entry.description}\nPublisher: ${entry.publisher}\nLicense: ${entry.license}\nSource: ${entry.sourceUrl}\nDelivery: ${JSON.stringify(delivery)}\n`)
-    } else {
-      const receipt = await harness.hub.install(id, version)
-      write(receipt.document ? `Saved ${target} in ${options.dataRoot}/hub/documents/${receipt.document}. Open this library in a compatible application to apply it.\n` : `Installed ${target}, switched off. Attach it separately${entry.delivery.kind === 'pi-package' ? ' and review/trust any code' : ''} before using it.\n`)
-    }
-    return 0
-  } catch (error) { write(`${error instanceof Error ? error.message : String(error)}\n`); return 1 }
-  finally { await harness.close() }
-}