[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6WXNZB5RT243V991HSD83VT":3,"skill-same:01M6WXNZB5RT243V991HSD83VT":83},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":23,"publishedAt":44,"linkOnly":45,"markdownContent":46,"markdownBody":47,"frontMatter":48,"refName":56,"commitSha":57,"skillDirectory":58,"forksCount":14,"repositoryHtmlUrl":59,"repositoryHomepageUrl":60,"ownerHtmlUrl":61,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":62,"install":63,"resources":76},"01M6WXNZB5RT243V991HSD83VT","go-conventions",null,"Go idioms — error wrapping, small interfaces, goroutine lifecycle, table-driven tests. Use when writing or reviewing Go code, designing package layouts, or working through concurrency, error handling, and testing decisions.","projectious-work\u002Fprocesskit","projectious-work","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F263889726?v=4","01M6N97TJJ118WQ35CHRV8RD0E","projectious.work","01M6N97TPWJPF0BMKYQ4PBY5W8",0,"MIT","https:\u002F\u002Fgithub.com\u002Fprojectious-work\u002Fprocesskit\u002Fblob\u002Fmain\u002Farchive\u002Fprocesskit-install-20261101\u002Fcontext\u002Ftemplates\u002Fprocesskit\u002Fv0.11.1\u002Fcontext\u002Fskills\u002Fengineering\u002Fgo-conventions\u002FSKILL.md",[18],{"categoryNo":19,"categoryName":20,"taxonomyType":21,"taxonomyTypeDesc":22},"01JBSEEDCAT000000000000008","测试与质量","SCENARIO","使用场景",[24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43],"go","go conventions","conventions","decisions","when","v1","error","driven","tests","idioms","use","testing","work","lifecycle","concurrency","engineering","package","error handling","code","writing","2026-11-10 10:12:30",false,"---\nname: go-conventions\ndescription: |\n  Go idioms — error wrapping, small interfaces, goroutine lifecycle, table-driven tests. Use when writing or reviewing Go code, designing package layouts, or working through concurrency, error handling, and testing decisions.\nmetadata:\n  processkit:\n    apiVersion: processkit.projectious.work\u002Fv1\n    id: SKILL-go-conventions\n    version: \"1.1.0\"\n    created: 2026-04-06T00:00:00Z\n    category: engineering\n---\n\n# Go Conventions\n\n## Intro\n\nIdiomatic Go is small interfaces, explicit error wrapping, clear\ngoroutine ownership, and domain-oriented packages. Follow `gofmt`,\nrespect `context.Context`, and never start a goroutine without\nknowing how it stops.\n\n## Overview\n\n### Error handling\n\nReturn errors as the last return value; never panic in library code.\nWrap with context using `fmt.Errorf(\"loading config: %w\", err)` so\ncallers can unwrap with `errors.Is` (sentinel errors) or `errors.As`\n(typed errors). Define sentinel errors at package level:\n`var ErrNotFound = errors.New(\"not found\")`. Use custom error types\nonly when callers need structured fields. Never silently ignore an\nerror — assigning to `_` requires a comment explaining why.\n\n### Interfaces\n\nAccept interfaces, return concrete types. Keep interfaces small —\n1–3 methods is ideal (\"the bigger the interface, the weaker the\nabstraction\"). Define interfaces where they are consumed, not where\nthey are implemented. Reach for stdlib interfaces (`io.Reader`,\n`io.Writer`, `fmt.Stringer`) before inventing new ones. Name\nsingle-method interfaces with the `-er` suffix.\n\n### Goroutine patterns\n\nPass `context.Context` as the first parameter to any function that\nblocks or does I\u002FO. Use `errgroup.Group` for fan-out\u002Ffan-in — it\nhandles error propagation and cancellation. Every goroutine must\nhave a clear owner responsible for its lifecycle. Always select on\n`ctx.Done()` alongside channel operations.\n\n### Package layout\n\nOrganize by domain, not by layer: `user\u002F`, `order\u002F`, not `models\u002F`,\n`handlers\u002F`. Package names are short, lowercase, and singular\n(`http`, `user`, `config`). Avoid catch-all `util`, `common`, and\n`helpers` packages. Keep `main.go` minimal — parse flags, wire\ndependencies, call `run(ctx)`. Put implementation details under\n`internal\u002F` to block external imports.\n\n### Testing\n\nUse table-driven tests with named subtests for multi-case coverage.\n`testify\u002Fassert` for readable checks, `testify\u002Frequire` for fatal\nones. Use `httptest.NewServer` for client tests, `NewRecorder` for\nhandler tests. Call `t.Helper()` in helpers so failures point at the\ncaller. Run `go test -race .\u002F...` in CI. Use `t.Parallel()` for\nindependent tests.\n\n### Code style\n\n`gofmt` is non-negotiable; `goimports` handles import grouping\n(stdlib, blank line, third-party, blank line, internal). Exported\nnames get doc comments that start with the name. Use named return\nvalues sparingly. Prefer early returns and guard clauses over deep\nnesting.\n\n## Gotchas\n\nAgent-specific failure modes — provider-neutral pause-and-self-check items:\n\n- **Goroutines with no visible stop condition.** Starting a goroutine without a `context.Context` cancellation path or a `done` channel means it may run forever after the caller is gone. Every goroutine must have an owner and a clear termination path.\n- **`panic` in library code for non-programmer-error conditions.** Library code must return errors, not panic, for any condition a caller might encounter in normal use. Reserve `panic` for programmer errors: nil pointers being dereferenced, impossible state. In application code `panic` is still rare; prefer `log.Fatal` + `os.Exit` at the `main` level.\n- **Large interfaces defined alongside their only implementation.** Interfaces should be defined where they are consumed, not where they are produced. A 10-method interface defined next to its sole implementation is not an abstraction — it is added complexity with no benefit.\n- **`util`, `common`, and `helpers` packages.** These names say nothing about what the code does and attract unrelated functions. Name packages by their domain and responsibility; if something doesn't fit a named package, question whether it belongs in the codebase.\n- **Silently ignoring errors with `_ =`.** Discarding an error without even a comment is a bug waiting to happen. When an error genuinely cannot matter, document why: `_ = f.Close() \u002F\u002F best-effort cleanup after write; error already reported`.\n- **Implementing the same interface in the same file as the interface definition.** Go's interface satisfaction is implicit; coupling the interface definition to the implementation defeats the decoupling purpose. Keep them in separate packages.\n- **`context.Background()` deep inside a call stack.** Creating a fresh `context.Background()` inside a called function discards cancellation and deadline signals from the caller. Accept `ctx context.Context` as the first parameter and propagate it.\n\n## Full reference\n\n### Functional options\n\nExtensible constructors that stay backward compatible:\n\n```go\ntype Server struct {\n    addr    string\n    timeout time.Duration\n    logger  *slog.Logger\n}\n\ntype Option func(*Server)\n\nfunc WithTimeout(d time.Duration) Option {\n    return func(s *Server) { s.timeout = d }\n}\n\nfunc NewServer(addr string, opts ...Option) *Server {\n    s := &Server{addr: addr, timeout: 30 * time.Second, logger: slog.Default()}\n    for _, opt := range opts {\n        opt(s)\n    }\n    return s\n}\n```\n\nUse when a constructor has 3+ optional parameters or when backward\ncompatibility matters on a public API.\n\n### Worker pool with errgroup\n\n```go\nfunc ProcessItems(ctx context.Context, items []Item, workers int) error {\n    g, ctx := errgroup.WithContext(ctx)\n    jobs := make(chan Item, workers)\n\n    g.Go(func() error {\n        defer close(jobs)\n        for _, item := range items {\n            select {\n            case jobs \u003C- item:\n            case \u003C-ctx.Done():\n                return ctx.Err()\n            }\n        }\n        return nil\n    })\n\n    for range workers {\n        g.Go(func() error {\n            for item := range jobs {\n                if err := process(ctx, item); err != nil {\n                    return fmt.Errorf(\"processing %s: %w\", item.ID, err)\n                }\n            }\n            return nil\n        })\n    }\n    return g.Wait()\n}\n```\n\n`errgroup.WithContext` cancels all goroutines on first error. Size\nthe buffer to the worker count. Always select on `ctx.Done()` in the\nproducer.\n\n### Graceful shutdown\n\n```go\nfunc run(ctx context.Context) error {\n    srv := &http.Server{Addr: \":8080\", Handler: mux}\n    errCh := make(chan error, 1)\n    go func() { errCh \u003C- srv.ListenAndServe() }()\n\n    select {\n    case err := \u003C-errCh:\n        return err\n    case \u003C-ctx.Done():\n    }\n\n    shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)\n    defer cancel()\n    return srv.Shutdown(shutdownCtx)\n}\n\nfunc main() {\n    ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)\n    defer stop()\n    if err := run(ctx); err != nil && !errors.Is(err, http.ErrServerClosed) {\n        slog.Error(\"server failed\", \"error\", err)\n        os.Exit(1)\n    }\n}\n```\n\n`signal.NotifyContext` for OS signals, `srv.Shutdown` to drain\nin-flight requests, timeout on shutdown so it never hangs forever.\n\n### Middleware chain\n\n```go\ntype Middleware func(http.Handler) http.Handler\n\nfunc Chain(h http.Handler, mw ...Middleware) http.Handler {\n    for i := len(mw) - 1; i >= 0; i-- {\n        h = mw[i](h)\n    }\n    return h\n}\n```\n\nFirst listed is outermost. See `references\u002Fgo-patterns.md` for\ncomplete logging and recovery middleware examples.\n\n### Table-driven tests\n\n```go\nfunc TestParseSize(t *testing.T) {\n    tests := []struct {\n        name    string\n        input   string\n        want    int64\n        wantErr bool\n    }{\n        {name: \"bytes\", input: \"100B\", want: 100},\n        {name: \"kilobytes\", input: \"2KB\", want: 2048},\n        {name: \"empty string\", input: \"\", wantErr: true},\n    }\n    for _, tt := range tests {\n        t.Run(tt.name, func(t *testing.T) {\n            t.Parallel()\n            got, err := ParseSize(tt.input)\n            if tt.wantErr {\n                require.Error(t, err)\n                return\n            }\n            require.NoError(t, err)\n            assert.Equal(t, tt.want, got)\n        })\n    }\n}\n```\n\nAlways use `t.Run` with named subtests. Put expected-error cases\nlast for readability.\n\n### Go proverbs worth tattooing\n\n- Don't communicate by sharing memory; share memory by communicating.\n- A little copying is better than a little dependency.\n- Clear is better than clever.\n- Make the zero value useful.\n- Errors are values — handle them, don't just check them.\n- The empty interface says nothing.\n\n### Anti-patterns\n\n- Goroutines with no visible stop condition.\n- `panic` in library code for non-programmer-error conditions.\n- Large interfaces defined alongside their sole implementation.\n- `util`\u002F`common`\u002F`helpers` packages that accrete unrelated code.\n- Ignoring errors without a `_ =` plus justification comment.\n- Naked returns in long functions where named returns obscure flow.\n\n### Further reading\n\n- `references\u002Fgo-patterns.md` — full functional options, middleware,\n  worker pool, and graceful shutdown examples.\n","# Go Conventions\n\n## Intro\n\nIdiomatic Go is small interfaces, explicit error wrapping, clear\ngoroutine ownership, and domain-oriented packages. Follow `gofmt`,\nrespect `context.Context`, and never start a goroutine without\nknowing how it stops.\n\n## Overview\n\n### Error handling\n\nReturn errors as the last return value; never panic in library code.\nWrap with context using `fmt.Errorf(\"loading config: %w\", err)` so\ncallers can unwrap with `errors.Is` (sentinel errors) or `errors.As`\n(typed errors). Define sentinel errors at package level:\n`var ErrNotFound = errors.New(\"not found\")`. Use custom error types\nonly when callers need structured fields. Never silently ignore an\nerror — assigning to `_` requires a comment explaining why.\n\n### Interfaces\n\nAccept interfaces, return concrete types. Keep interfaces small —\n1–3 methods is ideal (\"the bigger the interface, the weaker the\nabstraction\"). Define interfaces where they are consumed, not where\nthey are implemented. Reach for stdlib interfaces (`io.Reader`,\n`io.Writer`, `fmt.Stringer`) before inventing new ones. Name\nsingle-method interfaces with the `-er` suffix.\n\n### Goroutine patterns\n\nPass `context.Context` as the first parameter to any function that\nblocks or does I\u002FO. Use `errgroup.Group` for fan-out\u002Ffan-in — it\nhandles error propagation and cancellation. Every goroutine must\nhave a clear owner responsible for its lifecycle. Always select on\n`ctx.Done()` alongside channel operations.\n\n### Package layout\n\nOrganize by domain, not by layer: `user\u002F`, `order\u002F`, not `models\u002F`,\n`handlers\u002F`. Package names are short, lowercase, and singular\n(`http`, `user`, `config`). Avoid catch-all `util`, `common`, and\n`helpers` packages. Keep `main.go` minimal — parse flags, wire\ndependencies, call `run(ctx)`. Put implementation details under\n`internal\u002F` to block external imports.\n\n### Testing\n\nUse table-driven tests with named subtests for multi-case coverage.\n`testify\u002Fassert` for readable checks, `testify\u002Frequire` for fatal\nones. Use `httptest.NewServer` for client tests, `NewRecorder` for\nhandler tests. Call `t.Helper()` in helpers so failures point at the\ncaller. Run `go test -race .\u002F...` in CI. Use `t.Parallel()` for\nindependent tests.\n\n### Code style\n\n`gofmt` is non-negotiable; `goimports` handles import grouping\n(stdlib, blank line, third-party, blank line, internal). Exported\nnames get doc comments that start with the name. Use named return\nvalues sparingly. Prefer early returns and guard clauses over deep\nnesting.\n\n## Gotchas\n\nAgent-specific failure modes — provider-neutral pause-and-self-check items:\n\n- **Goroutines with no visible stop condition.** Starting a goroutine without a `context.Context` cancellation path or a `done` channel means it may run forever after the caller is gone. Every goroutine must have an owner and a clear termination path.\n- **`panic` in library code for non-programmer-error conditions.** Library code must return errors, not panic, for any condition a caller might encounter in normal use. Reserve `panic` for programmer errors: nil pointers being dereferenced, impossible state. In application code `panic` is still rare; prefer `log.Fatal` + `os.Exit` at the `main` level.\n- **Large interfaces defined alongside their only implementation.** Interfaces should be defined where they are consumed, not where they are produced. A 10-method interface defined next to its sole implementation is not an abstraction — it is added complexity with no benefit.\n- **`util`, `common`, and `helpers` packages.** These names say nothing about what the code does and attract unrelated functions. Name packages by their domain and responsibility; if something doesn't fit a named package, question whether it belongs in the codebase.\n- **Silently ignoring errors with `_ =`.** Discarding an error without even a comment is a bug waiting to happen. When an error genuinely cannot matter, document why: `_ = f.Close() \u002F\u002F best-effort cleanup after write; error already reported`.\n- **Implementing the same interface in the same file as the interface definition.** Go's interface satisfaction is implicit; coupling the interface definition to the implementation defeats the decoupling purpose. Keep them in separate packages.\n- **`context.Background()` deep inside a call stack.** Creating a fresh `context.Background()` inside a called function discards cancellation and deadline signals from the caller. Accept `ctx context.Context` as the first parameter and propagate it.\n\n## Full reference\n\n### Functional options\n\nExtensible constructors that stay backward compatible:\n\n```go\ntype Server struct {\n    addr    string\n    timeout time.Duration\n    logger  *slog.Logger\n}\n\ntype Option func(*Server)\n\nfunc WithTimeout(d time.Duration) Option {\n    return func(s *Server) { s.timeout = d }\n}\n\nfunc NewServer(addr string, opts ...Option) *Server {\n    s := &Server{addr: addr, timeout: 30 * time.Second, logger: slog.Default()}\n    for _, opt := range opts {\n        opt(s)\n    }\n    return s\n}\n```\n\nUse when a constructor has 3+ optional parameters or when backward\ncompatibility matters on a public API.\n\n### Worker pool with errgroup\n\n```go\nfunc ProcessItems(ctx context.Context, items []Item, workers int) error {\n    g, ctx := errgroup.WithContext(ctx)\n    jobs := make(chan Item, workers)\n\n    g.Go(func() error {\n        defer close(jobs)\n        for _, item := range items {\n            select {\n            case jobs \u003C- item:\n            case \u003C-ctx.Done():\n                return ctx.Err()\n            }\n        }\n        return nil\n    })\n\n    for range workers {\n        g.Go(func() error {\n            for item := range jobs {\n                if err := process(ctx, item); err != nil {\n                    return fmt.Errorf(\"processing %s: %w\", item.ID, err)\n                }\n            }\n            return nil\n        })\n    }\n    return g.Wait()\n}\n```\n\n`errgroup.WithContext` cancels all goroutines on first error. Size\nthe buffer to the worker count. Always select on `ctx.Done()` in the\nproducer.\n\n### Graceful shutdown\n\n```go\nfunc run(ctx context.Context) error {\n    srv := &http.Server{Addr: \":8080\", Handler: mux}\n    errCh := make(chan error, 1)\n    go func() { errCh \u003C- srv.ListenAndServe() }()\n\n    select {\n    case err := \u003C-errCh:\n        return err\n    case \u003C-ctx.Done():\n    }\n\n    shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)\n    defer cancel()\n    return srv.Shutdown(shutdownCtx)\n}\n\nfunc main() {\n    ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)\n    defer stop()\n    if err := run(ctx); err != nil && !errors.Is(err, http.ErrServerClosed) {\n        slog.Error(\"server failed\", \"error\", err)\n        os.Exit(1)\n    }\n}\n```\n\n`signal.NotifyContext` for OS signals, `srv.Shutdown` to drain\nin-flight requests, timeout on shutdown so it never hangs forever.\n\n### Middleware chain\n\n```go\ntype Middleware func(http.Handler) http.Handler\n\nfunc Chain(h http.Handler, mw ...Middleware) http.Handler {\n    for i := len(mw) - 1; i >= 0; i-- {\n        h = mw[i](h)\n    }\n    return h\n}\n```\n\nFirst listed is outermost. See `references\u002Fgo-patterns.md` for\ncomplete logging and recovery middleware examples.\n\n### Table-driven tests\n\n```go\nfunc TestParseSize(t *testing.T) {\n    tests := []struct {\n        name    string\n        input   string\n        want    int64\n        wantErr bool\n    }{\n        {name: \"bytes\", input: \"100B\", want: 100},\n        {name: \"kilobytes\", input: \"2KB\", want: 2048},\n        {name: \"empty string\", input: \"\", wantErr: true},\n    }\n    for _, tt := range tests {\n        t.Run(tt.name, func(t *testing.T) {\n            t.Parallel()\n            got, err := ParseSize(tt.input)\n            if tt.wantErr {\n                require.Error(t, err)\n                return\n            }\n            require.NoError(t, err)\n            assert.Equal(t, tt.want, got)\n        })\n    }\n}\n```\n\nAlways use `t.Run` with named subtests. Put expected-error cases\nlast for readability.\n\n### Go proverbs worth tattooing\n\n- Don't communicate by sharing memory; share memory by communicating.\n- A little copying is better than a little dependency.\n- Clear is better than clever.\n- Make the zero value useful.\n- Errors are values — handle them, don't just check them.\n- The empty interface says nothing.\n\n### Anti-patterns\n\n- Goroutines with no visible stop condition.\n- `panic` in library code for non-programmer-error conditions.\n- Large interfaces defined alongside their sole implementation.\n- `util`\u002F`common`\u002F`helpers` packages that accrete unrelated code.\n- Ignoring errors without a `_ =` plus justification comment.\n- Naked returns in long functions where named returns obscure flow.\n\n### Further reading\n\n- `references\u002Fgo-patterns.md` — full functional options, middleware,\n  worker pool, and graceful shutdown examples.\n",{"name":5,"metadata":49,"description":55},{"processkit":50},{"id":51,"created":52,"version":53,"category":39,"apiVersion":54},"SKILL-go-conventions",1775433600000,"1.1.0","processkit.projectious.work\u002Fv1","Go idioms — error wrapping, small interfaces, goroutine lifecycle, table-driven tests. Use when writing or reviewing Go code, designing package layouts, or working through concurrency, error handling, and testing decisions.\n","main","4876a92620ee792aac2ac9a1a806322d8a572367","archive\u002Fprocesskit-install-20261101\u002Fcontext\u002Ftemplates\u002Fprocesskit\u002Fv0.11.1\u002Fcontext\u002Fskills\u002Fengineering\u002Fgo-conventions","https:\u002F\u002Fgithub.com\u002Fprojectious-work\u002Fprocesskit","https:\u002F\u002Fprojectious-work.github.io\u002Fprocesskit\u002F","https:\u002F\u002Fgithub.com\u002Fprojectious-work","2026-11-11 23:24:18",{"source":8,"skillName":5,"commands":64,"prompt":74,"zipAvailable":75},[65,68,71],{"tool":66,"command":67},"npx","npx skills add projectious-work\u002Fprocesskit --skill go-conventions",{"tool":69,"command":70},"bunx","bunx skills add projectious-work\u002Fprocesskit --skill go-conventions",{"tool":72,"command":73},"pnpm","pnpm dlx skills add projectious-work\u002Fprocesskit --skill go-conventions","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fprojectious-work\u002Fprocesskit\u002Fblob\u002Fmain\u002Farchive\u002Fprocesskit-install-20261101\u002Fcontext\u002Ftemplates\u002Fprocesskit\u002Fv0.11.1\u002Fcontext\u002Fskills\u002Fengineering\u002Fgo-conventions\u002FSKILL.md",true,[77],{"path":78,"resourceType":79,"resourceTypeDesc":80,"sizeBytes":81,"sourceHtmlUrl":82},"references\u002Fgo-patterns.md","REFERENCE","参考文档",5513,"https:\u002F\u002Fgithub.com\u002Fprojectious-work\u002Fprocesskit\u002Fblob\u002Fmain\u002Farchive\u002Fprocesskit-install-20261101\u002Fcontext\u002Ftemplates\u002Fprocesskit\u002Fv0.11.1\u002Fcontext\u002Fskills\u002Fengineering\u002Fgo-conventions\u002Freferences\u002Fgo-patterns.md",[84,107,127,148,164,182],{"skillNo":85,"name":86,"nameZh":6,"description":87,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":88,"categories":89,"keywords":93,"publishedAt":44},"01M6X5MTC89B4ZGXW3JVSQCPF8","skill-management","Manage Skill package manifests as v1 ontology entities.","https:\u002F\u002Fgithub.com\u002Fprojectious-work\u002Fprocesskit\u002Fblob\u002Fmain\u002Fsrc\u002Fcontext\u002Fskills\u002Fprocesskit\u002Fskill-management\u002FSKILL.md",[90],{"categoryNo":91,"categoryName":92,"taxonomyType":21,"taxonomyTypeDesc":22},"01JBSEEDCAT000000000000023","Skill与智能体开发",[94,95,96,97,40,98,36,99,100,101,86,102,103,104,29,105,106],"management","skill management","create","update","alpha","list","manage","ontology","get","as","manifests","skill package","transition",{"skillNo":108,"name":109,"nameZh":6,"description":110,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":111,"categories":112,"keywords":114,"publishedAt":44},"01M6X5MCV74NHW5MEDNHZRF2C8","schema-management","Manage generated processkit schema contracts through deterministic MCP rebuild and inspection workflows.","https:\u002F\u002Fgithub.com\u002Fprojectious-work\u002Fprocesskit\u002Fblob\u002Fmain\u002Fsrc\u002Fcontext\u002Fskills\u002Fprocesskit\u002Fschema-management\u002FSKILL.md",[113],{"categoryNo":91,"categoryName":92,"taxonomyType":21,"taxonomyTypeDesc":22},[94,115,116,117,118,119,98,36,120,121,100,122,123,124,102,125,126],"schema","schema management","MCP","workflows","validation","generated","rebuild","contracts","wed","deterministic","contract","mode",{"skillNo":128,"name":129,"nameZh":6,"description":130,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":131,"categories":132,"keywords":133,"publishedAt":44},"01M6X5M5G6YJ96AMZGSCZJ1D13","proposition-management","Record claims, risks, beliefs, world facts, WSJF estimates, and assumptions through the Proposition interface.","https:\u002F\u002Fgithub.com\u002Fprojectious-work\u002Fprocesskit\u002Fblob\u002Fmain\u002Fsrc\u002Fcontext\u002Fskills\u002Fprocesskit\u002Fproposition-management\u002FSKILL.md",[],[94,134,135,96,97,136,98,36,137,138,139,140,102,141,142,143,144,145,146,147],"proposition","proposition management","index","log","world","record","query","creation","event","interface","updates","facts","claims","WSJF",{"skillNo":149,"name":150,"nameZh":6,"description":151,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":152,"categories":153,"keywords":154,"publishedAt":44},"01M6X5KMQ83QN9M6MPWZM7344F","ontology-management","Manage generated v1 ontology entities that do not require a dedicated domain server.","https:\u002F\u002Fgithub.com\u002Fprojectious-work\u002Fprocesskit\u002Fblob\u002Fmain\u002Fsrc\u002Fcontext\u002Fskills\u002Fprocesskit\u002Fontology-management\u002FSKILL.md",[],[94,101,155,96,98,37,156,120,157,137,100,158,159,102,160,161,142,162,29,163],"ontology management","archive","roadmap","do","domain","iteration","keep","measurement","generic",{"skillNo":165,"name":166,"nameZh":6,"description":167,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":168,"categories":169,"keywords":170,"publishedAt":44},"01M6X5KCY2DN3SM21RERSFNEBT","okf-compatibility","Import, export, and validate conformant Open Knowledge Format bundles.","https:\u002F\u002Fgithub.com\u002Fprojectious-work\u002Fprocesskit\u002Fblob\u002Fmain\u002Fsrc\u002Fcontext\u002Fskills\u002Fprocesskit\u002Fokf-compatibility\u002FSKILL.md",[],[171,172,173,174,98,175,176,177,36,178,179,180,181],"okf","compatibility","okf compatibility","validate","open","knowledge","format","export","bundles","bundle","import",{"skillNo":183,"name":184,"nameZh":6,"description":185,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":186,"categories":187,"keywords":188,"publishedAt":44},"01M6X5JA8S5PNGJVFW4EQY8T83","capability-management","Manage versioned Capability entities and their governed lifecycle.","https:\u002F\u002Fgithub.com\u002Fprojectious-work\u002Fprocesskit\u002Fblob\u002Fmain\u002Fsrc\u002Fcontext\u002Fskills\u002Fprocesskit\u002Fcapability-management\u002FSKILL.md",[],[94,189,190,96,97,136,98,37,36,99,137,191,100,139,102,161,142,143,192,106],"capability","capability management","queries","changes"]