@mindot/will 0.1.0

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@mindot/will",
+  "version": "0.1.0",
+  "description": "Will — an engine for persistent machine minds. A Will is a continuously-ticking synthetic mind built from 38 cognitive faculties, a learning agency pipeline, and a dual-process executive — deterministic, persistent, and portable (PMA).",
+  "author": "Fabrice <fabrice8@github.com>",
+  "license": "Apache-2.0",
+  "packageManager": "bun@1.3.9",
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "homepage": "https://github.com/mindot-ai/will#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mindot-ai/will.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mindot-ai/will/issues"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "ai-agents",
+    "cognitive-architecture",
+    "generative-agents",
+    "persistent-memory",
+    "simulation",
+    "autonomous-agent",
+    "llm",
+    "npc",
+    "mind",
+    "deterministic"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": ["dist", "src"],
+  "scripts": {
+    "build": "tsup",
+    "build:types": "tsc --project tsconfig.build.json",
+    "dev": "bun --env-file=.env run src/runners/thin-shim.runner.ts",
+    "dev:build": "tsup --watch",
+    "run:social": "bun --env-file=.env run src/runners/social.runner.ts",
+    "run:outreach": "bun --env-file=.env run src/runners/outreach.runner.ts",
+    "start": "bun --env-file=.env run src/runners/thin-shim.runner.ts",
+    "typecheck": "tsc --noEmit",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "bun run typecheck && bun test && bun run build",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:integration": "vitest run src/tests/integration"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.1048.0"
+  },
+  "optionalDependencies": {
+    "socket.io-client": "^4.8.1"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.0",
+    "vitest": "^4.1.5"
+  }
+}

package/src/cognition/agency/access.grants.ts

@@ -0,0 +1,59 @@
+// ─────────────────────────────────────────────────────────────
+// src/agency/access.grants.ts  —  the access-grant layer
+// ─────────────────────────────────────────────────────────────
+//
+// The agency-native permission primitive. It replaces the permission/sense-gate
+// role the legacy effectorRegistry used to carry (the catalog/discovery/created-
+// effector machinery is retired separately). A Will's communication surface is
+// closed by default: `listen`, `talk`, `text`, `gesture`, `broadcast` each
+// require an explicit grant; everything else is freely available.
+//
+// Semantics are preserved verbatim from effectorRegistry's permission methods so
+// the migration is behaviour-identical:
+//   • non-explicit name      → always allowed
+//   • explicit name granted  → allowed
+//   • explicit name ungranted→ denied
+//
+// The backend's `PATCH /v1/wills/:id/effectors` reaches this via the unchanged
+// `WillStem.setAllowedEffectors` → effectorController → `setAllowed`.
+// ─────────────────────────────────────────────────────────────
+
+/** The communication surface — these names are denied unless explicitly granted. */
+export const EXPLICIT_EFFECTORS: ReadonlySet<string> = new Set( [
+  'listen', 'talk', 'text', 'gesture', 'broadcast',
+] )
+
+export class AccessGrants {
+  private _granted: Set<string>
+
+  /** Seed from the resolved allow-list (e.g. profile effectors). null/[] ⇒ none granted. */
+  constructor( initial?: string[] | null ){
+    this._granted = new Set( ( initial ?? [] ).filter( n => EXPLICIT_EFFECTORS.has( n ) ) )
+  }
+
+  /** Is the Will permitted to use this effector/schema right now? */
+  isAllowed( name: string ): boolean {
+    if( !EXPLICIT_EFFECTORS.has( name ) ) return true
+    return this._granted.has( name )
+  }
+
+  /** Grant one explicit effector (no-op for non-explicit names). */
+  allow( name: string ): void {
+    if( EXPLICIT_EFFECTORS.has( name ) ) this._granted.add( name )
+  }
+
+  /** Revoke one effector. */
+  revoke( name: string ): void {
+    this._granted.delete( name )
+  }
+
+  /** Replace the entire grant set (runtime reconfiguration). */
+  setAllowed( names: string[] | null ): void {
+    this._granted = new Set( ( names ?? [] ).filter( n => EXPLICIT_EFFECTORS.has( n ) ) )
+  }
+
+  /** The currently granted explicit effectors. */
+  granted(): string[] {
+    return [ ...this._granted ]
+  }
+}

package/src/cognition/agency/competence.codec.ts

@@ -0,0 +1,89 @@
+// ─────────────────────────────────────────────────────────────
+// src/agency/competence.codec.ts  —  portable competence
+// ─────────────────────────────────────────────────────────────
+//
+// The original PMA carried who a Will *is*, *believes*, and *cares about* — but
+// not what it had *learned to do*. A person who keeps their opinions and bonds
+// but forgets every skill each morning is not continuity. This codec closes that
+// gap: it distills the competence layer (learned composite schemas + their
+// LearnedSkill stats) into a portable fragment, and reloads it so a re-embodied
+// Will *acts like itself* — its habits, its proceduralized skills, its learned
+// parameter defaults — not just feels and believes like itself.
+//
+// Soul doctrine (mirrors the existing PMA relationship distiller): what
+// crystallizes across a restart is what *mattered*. Fleeting, barely-practiced
+// skills fall below the carry floor and fade — the forgetting curve, made
+// portable. Strong habits carry.
+// ─────────────────────────────────────────────────────────────
+
+import type { MotorSchema, LearnedSkill } from '#agency/types'
+import type { SchemaRepertoire } from '#agency/schemas/repertoire'
+
+export const COMPETENCE_SCHEMA_VERSION = 1
+
+export interface CompetenceSnapshot {
+  schemaVersion: number
+  /** Learned composite schema DEFINITIONS (the innate floor is intrinsic — not carried). */
+  composites: MotorSchema[]
+  /** Per-schema learned skills above the carry floor, ranked by consolidation. */
+  skills: LearnedSkill[]
+}
+
+export interface DistillOptions {
+  /** Skills below this habit strength are not carried (the forgetting floor). */
+  minHabit?: number
+  /** Cap on carried skills, ranked by consolidation. */
+  maxSkills?: number
+}
+
+const DEFAULT_MIN_HABIT = 0.2
+const DEFAULT_MAX_SKILLS = 50
+
+/** Consolidation score — how much a skill has "set" — used for ranking the carry. */
+function consolidation( s: LearnedSkill ): number {
+  return s.habitStrength * 0.6
+    + s.valueEstimate * 0.2
+    + Math.min( 1, s.enactments * 0.02 ) * 0.2
+}
+
+/**
+ * Distill the repertoire's competence into a portable snapshot. Carries the
+ * strongest skills (above the floor) and only the learned composite templates
+ * that still have a carried skill — so no orphan templates ride along.
+ */
+export function distillCompetence(
+  repertoire: SchemaRepertoire,
+  opts: DistillOptions = {},
+): CompetenceSnapshot {
+  const minHabit  = opts.minHabit  ?? DEFAULT_MIN_HABIT
+  const maxSkills = opts.maxSkills ?? DEFAULT_MAX_SKILLS
+
+  const { composites, skills } = repertoire.export( minHabit )
+
+  const carriedSkills = [ ...skills ]
+    .sort( ( a, b ) => consolidation( b ) - consolidation( a ) )
+    .slice( 0, maxSkills )
+
+  const carriedIds = new Set( carriedSkills.map( s => s.schema ) )
+  const carriedComposites = composites.filter( c => carriedIds.has( c.id ) )
+
+  return {
+    schemaVersion: COMPETENCE_SCHEMA_VERSION,
+    composites:    carriedComposites,
+    skills:        carriedSkills,
+  }
+}
+
+/**
+ * Reload a competence snapshot into a (typically fresh) repertoire, so the Will
+ * resumes with its learned skills and composites intact. Composites are
+ * registered first (re-creating their templates), then skills overwrite the
+ * fresh stubs with the carried, consolidated values.
+ */
+export function loadCompetence(
+  snapshot: CompetenceSnapshot | null | undefined,
+  repertoire: SchemaRepertoire,
+): void {
+  if( !snapshot || snapshot.schemaVersion !== COMPETENCE_SCHEMA_VERSION ) return
+  repertoire.import({ composites: snapshot.composites, skills: snapshot.skills })
+}